Add volatile to PPC_DCBST, PPC_SYNC, and PPC_ICBI asm for broken compilers.
[kopensolaris-gnu/glibc.git] / sysdeps / powerpc / dl-machine.c
1 /* Machine-dependent ELF dynamic relocation functions.  PowerPC version.
2    Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000 
3    Free Software Foundation, Inc.
4    This file is part of the GNU C Library.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Library General Public License as
8    published by the Free Software Foundation; either version 2 of the
9    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    Library General Public License for more details.
15
16    You should have received a copy of the GNU Library General Public
17    License along with the GNU C Library; see the file COPYING.LIB.  If not,
18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19    Boston, MA 02111-1307, USA.  */
20
21 #include <unistd.h>
22 #include <string.h>
23 #include <sys/param.h>
24 #include <link.h>
25 #include <ldsodefs.h>
26 #include <elf/dynamic-link.h>
27 #include <dl-machine.h>
28
29 /* Because ld.so is now versioned, these functions can be in their own file;
30    no relocations need to be done to call them.
31    Of course, if ld.so is not versioned...  */
32 #if !(DO_VERSIONING - 0)
33 #error This will not work with versioning turned off, sorry.
34 #endif
35
36
37 /* Stuff for the PLT.  */
38 #define PLT_INITIAL_ENTRY_WORDS 18
39 #define PLT_LONGBRANCH_ENTRY_WORDS 0
40 #define PLT_TRAMPOLINE_ENTRY_WORDS 6
41 #define PLT_DOUBLE_SIZE (1<<13)
42 #define PLT_ENTRY_START_WORDS(entry_number) \
43   (PLT_INITIAL_ENTRY_WORDS + (entry_number)*2                           \
44    + ((entry_number) > PLT_DOUBLE_SIZE                                  \
45       ? ((entry_number) - PLT_DOUBLE_SIZE)*2                            \
46       : 0))
47 #define PLT_DATA_START_WORDS(num_entries) PLT_ENTRY_START_WORDS(num_entries)
48
49 /* Macros to build PowerPC opcode words.  */
50 #define OPCODE_ADDI(rd,ra,simm) \
51   (0x38000000 | (rd) << 21 | (ra) << 16 | ((simm) & 0xffff))
52 #define OPCODE_ADDIS(rd,ra,simm) \
53   (0x3c000000 | (rd) << 21 | (ra) << 16 | ((simm) & 0xffff))
54 #define OPCODE_ADD(rd,ra,rb) \
55   (0x7c000214 | (rd) << 21 | (ra) << 16 | (rb) << 11)
56 #define OPCODE_B(target) (0x48000000 | ((target) & 0x03fffffc))
57 #define OPCODE_BA(target) (0x48000002 | ((target) & 0x03fffffc))
58 #define OPCODE_BCTR() 0x4e800420
59 #define OPCODE_LWZ(rd,d,ra) \
60   (0x80000000 | (rd) << 21 | (ra) << 16 | ((d) & 0xffff))
61 #define OPCODE_LWZU(rd,d,ra) \
62   (0x84000000 | (rd) << 21 | (ra) << 16 | ((d) & 0xffff))
63 #define OPCODE_MTCTR(rd) (0x7C0903A6 | (rd) << 21)
64 #define OPCODE_RLWINM(ra,rs,sh,mb,me) \
65   (0x54000000 | (rs) << 21 | (ra) << 16 | (sh) << 11 | (mb) << 6 | (me) << 1)
66
67 #define OPCODE_LI(rd,simm)    OPCODE_ADDI(rd,0,simm)
68 #define OPCODE_ADDIS_HI(rd,ra,value) \
69   OPCODE_ADDIS(rd,ra,((value) + 0x8000) >> 16)
70 #define OPCODE_LIS_HI(rd,value) OPCODE_ADDIS_HI(rd,0,value)
71 #define OPCODE_SLWI(ra,rs,sh) OPCODE_RLWINM(ra,rs,sh,0,31-sh)
72
73
74 #define PPC_DCBST(where) asm volatile ("dcbst 0,%0" : : "r"(where) : "memory")
75 #define PPC_SYNC asm volatile ("sync" : : : "memory")
76 #define PPC_ISYNC asm volatile ("sync; isync" : : : "memory")
77 #define PPC_ICBI(where) asm volatile ("icbi 0,%0" : : "r"(where) : "memory")
78 #define PPC_DIE asm volatile ("tweq 0,0")
79
80 /* Use this when you've modified some code, but it won't be in the
81    instruction fetch queue (or when it doesn't matter if it is). */
82 #define MODIFIED_CODE_NOQUEUE(where) \
83      do { PPC_DCBST(where); PPC_SYNC; PPC_ICBI(where); } while (0)
84 /* Use this when it might be in the instruction queue. */
85 #define MODIFIED_CODE(where) \
86      do { PPC_DCBST(where); PPC_SYNC; PPC_ICBI(where); PPC_ISYNC; } while (0)
87
88
89 /* The idea here is that to conform to the ABI, we are supposed to try
90    to load dynamic objects between 0x10000 (we actually use 0x40000 as
91    the lower bound, to increase the chance of a memory reference from
92    a null pointer giving a segfault) and the program's load address;
93    this may allow us to use a branch instruction in the PLT rather
94    than a computed jump.  The address is only used as a preference for
95    mmap, so if we get it wrong the worst that happens is that it gets
96    mapped somewhere else.  */
97
98 ElfW(Addr)
99 __elf_preferred_address(struct link_map *loader, size_t maplength,
100                         ElfW(Addr) mapstartpref)
101 {
102   ElfW(Addr) low, high;
103   struct link_map *l;
104
105   /* If the object has a preference, load it there!  */
106   if (mapstartpref != 0)
107     return mapstartpref;
108
109   /* Otherwise, quickly look for a suitable gap between 0x3FFFF and
110      0x70000000.  0x3FFFF is so that references off NULL pointers will
111      cause a segfault, 0x70000000 is just paranoia (it should always
112      be superceded by the program's load address).  */
113   low =  0x0003FFFF;
114   high = 0x70000000;
115   for (l = _dl_loaded; l; l = l->l_next)
116     {
117       ElfW(Addr) mapstart, mapend;
118       mapstart = l->l_map_start & ~(_dl_pagesize - 1);
119       mapend = l->l_map_end | (_dl_pagesize - 1);
120       assert (mapend > mapstart);
121
122       if (mapend >= high && high >= mapstart)
123         high = mapstart;
124       else if (mapend >= low && low >= mapstart)
125         low = mapend;
126       else if (high >= mapend && mapstart >= low)
127         {
128           if (high - mapend >= mapstart - low)
129             low = mapend;
130           else
131             high = mapstart;
132         }
133     }
134
135   high -= 0x10000; /* Allow some room between objects.  */
136   maplength = (maplength | (_dl_pagesize-1)) + 1;
137   if (high <= low || high - low < maplength )
138     return 0;
139   return high - maplength;  /* Both high and maplength are page-aligned.  */
140 }
141
142 /* Set up the loaded object described by L so its unrelocated PLT
143    entries will jump to the on-demand fixup code in dl-runtime.c.
144    Also install a small trampoline to be used by entries that have
145    been relocated to an address too far away for a single branch.  */
146
147 /* There are many kinds of PLT entries:
148
149    (1)  A direct jump to the actual routine, either a relative or
150         absolute branch.  These are set up in __elf_machine_fixup_plt.
151
152    (2)  Short lazy entries.  These cover the first 8192 slots in
153         the PLT, and look like (where 'index' goes from 0 to 8191):
154
155         li %r11, index*4
156         b  &plt[PLT_TRAMPOLINE_ENTRY_WORDS+1]
157
158    (3)  Short indirect jumps.  These replace (2) when a direct jump
159         wouldn't reach.  They look the same except that the branch
160         is 'b &plt[PLT_LONGBRANCH_ENTRY_WORDS]'.
161
162    (4)  Long lazy entries.  These cover the slots when a short entry
163         won't fit ('index*4' overflows its field), and look like:
164
165         lis %r11, %hi(index*4 + &plt[PLT_DATA_START_WORDS])
166         lwzu %r12, %r11, %lo(index*4 + &plt[PLT_DATA_START_WORDS])
167         b  &plt[PLT_TRAMPOLINE_ENTRY_WORDS]
168         bctr
169
170    (5)  Long indirect jumps.  These replace (4) when a direct jump
171         wouldn't reach.  They look like:
172
173         lis %r11, %hi(index*4 + &plt[PLT_DATA_START_WORDS])
174         lwz %r12, %r11, %lo(index*4 + &plt[PLT_DATA_START_WORDS])
175         mtctr %r12
176         bctr
177
178    (6) Long direct jumps.  These are used when thread-safety is not
179        required.  They look like:
180
181        lis %r12, %hi(finaladdr)
182        addi %r12, %r12, %lo(finaladdr)
183        mtctr %r12
184        bctr
185
186
187    The lazy entries, (2) and (4), are set up here in
188    __elf_machine_runtime_setup.  (1), (3), and (5) are set up in
189    __elf_machine_fixup_plt.  (1), (3), and (6) can also be constructed
190    in __process_machine_rela.
191
192    The reason for the somewhat strange construction of the long
193    entries, (4) and (5), is that we need to ensure thread-safety.  For
194    (1) and (3), this is obvious because only one instruction is
195    changed and the PPC architecture guarantees that aligned stores are
196    atomic.  For (5), this is more tricky.  When changing (4) to (5),
197    the `b' instruction is first changed to to `mtctr'; this is safe
198    and is why the `lwzu' instruction is not just a simple `addi'.
199    Once this is done, and is visible to all processors, the `lwzu' can
200    safely be changed to a `lwz'.  */
201 int
202 __elf_machine_runtime_setup (struct link_map *map, int lazy, int profile)
203 {
204   if (map->l_info[DT_JMPREL])
205     {
206       Elf32_Word i;
207       Elf32_Word *plt = (Elf32_Word *) D_PTR (map, l_info[DT_PLTGOT]);
208       Elf32_Word num_plt_entries = (map->l_info[DT_PLTRELSZ]->d_un.d_val
209                                     / sizeof (Elf32_Rela));
210       Elf32_Word rel_offset_words = PLT_DATA_START_WORDS (num_plt_entries);
211       Elf32_Word data_words = (Elf32_Word) (plt + rel_offset_words);
212       Elf32_Word size_modified;
213
214       extern void _dl_runtime_resolve (void);
215       extern void _dl_prof_resolve (void);
216
217       /* Convert the index in r11 into an actual address, and get the
218          word at that address.  */
219       plt[PLT_LONGBRANCH_ENTRY_WORDS] = OPCODE_ADDIS_HI (11, 11, data_words);
220       plt[PLT_LONGBRANCH_ENTRY_WORDS + 1] = OPCODE_LWZ (11, data_words, 11);
221
222       /* Call the procedure at that address.  */
223       plt[PLT_LONGBRANCH_ENTRY_WORDS + 2] = OPCODE_MTCTR (11);
224       plt[PLT_LONGBRANCH_ENTRY_WORDS + 3] = OPCODE_BCTR ();
225
226       if (lazy)
227         {
228           Elf32_Word *tramp = plt + PLT_TRAMPOLINE_ENTRY_WORDS;
229           Elf32_Word dlrr = (Elf32_Word)(profile
230                                          ? _dl_prof_resolve
231                                          : _dl_runtime_resolve);
232           Elf32_Word offset;
233
234           if (profile && _dl_name_match_p (_dl_profile, map))
235             /* This is the object we are looking for.  Say that we really
236                want profiling and the timers are started.  */
237             _dl_profile_map = map;
238           
239           /* For the long entries, subtract off data_words.  */
240           tramp[0] = OPCODE_ADDIS_HI (11, 11, -data_words);
241           tramp[1] = OPCODE_ADDI (11, 11, -data_words);
242           
243           /* Multiply index of entry by 3 (in r11).  */
244           tramp[2] = OPCODE_SLWI (12, 11, 1);
245           tramp[3] = OPCODE_ADD (11, 12, 11);
246           if (dlrr <= 0x01fffffc || dlrr >= 0xfe000000)
247             {
248               /* Load address of link map in r12.  */
249               tramp[4] = OPCODE_LI (12, (Elf32_Word) map);
250               tramp[5] = OPCODE_ADDIS_HI (12, 12, (Elf32_Word) map);
251               
252               /* Call _dl_runtime_resolve.  */
253               tramp[6] = OPCODE_BA (dlrr);
254             }
255           else
256             {
257               /* Get address of _dl_runtime_resolve in CTR.  */
258               tramp[4] = OPCODE_LI (12, dlrr);
259               tramp[5] = OPCODE_ADDIS_HI (12, 12, dlrr);
260               tramp[6] = OPCODE_MTCTR (12);
261               
262               /* Load address of link map in r12.  */
263               tramp[7] = OPCODE_LI (12, (Elf32_Word) map);
264               tramp[8] = OPCODE_ADDIS_HI (12, 12, (Elf32_Word) map);
265               
266               /* Call _dl_runtime_resolve.  */
267               tramp[9] = OPCODE_BCTR ();
268             }
269           
270           /* Set up the lazy PLT entries.  */
271           offset = PLT_INITIAL_ENTRY_WORDS;
272           i = 0;
273           while (i < num_plt_entries && i < PLT_DOUBLE_SIZE)
274             {
275               plt[offset  ] = OPCODE_LI (11, i * 4);
276               plt[offset+1] = OPCODE_B ((PLT_TRAMPOLINE_ENTRY_WORDS + 2
277                                          - (offset+1))
278                                         * 4);
279               i++;
280               offset += 2;
281             }
282           while (i < num_plt_entries)
283             {
284               plt[offset  ] = OPCODE_LIS_HI (11, i * 4 + data_words);
285               plt[offset+1] = OPCODE_LWZU (12, i * 4 + data_words, 11);
286               plt[offset+2] = OPCODE_B ((PLT_TRAMPOLINE_ENTRY_WORDS
287                                          - (offset+2))
288                                         * 4);
289               plt[offset+3] = OPCODE_BCTR ();
290               i++;
291               offset += 4;
292             }
293         }
294
295       /* Now, we've modified code.  We need to write the changes from
296          the data cache to a second-level unified cache, then make
297          sure that stale data in the instruction cache is removed.
298          (In a multiprocessor system, the effect is more complex.)
299          Most of the PLT shouldn't be in the instruction cache, but
300          there may be a little overlap at the start and the end.
301
302          Assumes that dcbst and icbi apply to lines of 16 bytes or
303          more.  Current known line sizes are 16, 32, and 128 bytes.  */
304
305       size_modified = lazy ? rel_offset_words : 6;
306       for (i = 0; i < size_modified; i += 4)
307         PPC_DCBST (plt + i);
308       PPC_DCBST (plt + size_modified - 1);
309       PPC_SYNC;
310       PPC_ICBI (plt);
311       PPC_ICBI (plt + size_modified - 1);
312       PPC_ISYNC;
313     }
314
315   return lazy;
316 }
317
318 Elf32_Addr
319 __elf_machine_fixup_plt(struct link_map *map, const Elf32_Rela *reloc,
320                         Elf32_Addr *reloc_addr, Elf32_Addr finaladdr)
321 {
322   Elf32_Sword delta = finaladdr - (Elf32_Word) reloc_addr;
323   if (delta << 6 >> 6 == delta)
324     *reloc_addr = OPCODE_B (delta);
325   else if (finaladdr <= 0x01fffffc || finaladdr >= 0xfe000000)
326     *reloc_addr = OPCODE_BA (finaladdr);
327   else
328     {
329       Elf32_Word *plt, *data_words;
330       Elf32_Word index, offset, num_plt_entries;
331       
332       num_plt_entries = (map->l_info[DT_PLTRELSZ]->d_un.d_val
333                          / sizeof(Elf32_Rela));
334       plt = (Elf32_Word *) D_PTR (map, l_info[DT_PLTGOT]);
335       offset = reloc_addr - plt;
336       index = (offset - PLT_INITIAL_ENTRY_WORDS)/2;
337       data_words = plt + PLT_DATA_START_WORDS (num_plt_entries);
338
339       reloc_addr += 1;
340
341       if (index < PLT_DOUBLE_SIZE)
342         {
343           data_words[index] = finaladdr;
344           PPC_SYNC;
345           *reloc_addr = OPCODE_B ((PLT_LONGBRANCH_ENTRY_WORDS - (offset+1)) 
346                                   * 4);
347         }
348       else
349         {
350           index -= (index - PLT_DOUBLE_SIZE)/2;
351
352           data_words[index] = finaladdr;
353           PPC_SYNC;
354
355           reloc_addr[1] = OPCODE_MTCTR (12);
356           MODIFIED_CODE_NOQUEUE (reloc_addr + 1);
357           PPC_SYNC;
358
359           reloc_addr[0] = OPCODE_LWZ (12,
360                                       (Elf32_Word) (data_words + index), 11);
361         }
362     }
363   MODIFIED_CODE (reloc_addr);
364   return finaladdr;
365 }
366
367 void
368 __process_machine_rela (struct link_map *map,
369                         const Elf32_Rela *reloc,
370                         const Elf32_Sym *sym,
371                         const Elf32_Sym *refsym,
372                         Elf32_Addr *const reloc_addr,
373                         Elf32_Addr const finaladdr,
374                         int rinfo)
375 {
376   switch (rinfo)
377     {
378     case R_PPC_NONE:
379       return;
380
381     case R_PPC_ADDR32:
382     case R_PPC_UADDR32:
383     case R_PPC_GLOB_DAT:
384     case R_PPC_RELATIVE:
385       *reloc_addr = finaladdr;
386       return;
387
388     case R_PPC_ADDR24:
389       if (finaladdr > 0x01fffffc && finaladdr < 0xfe000000)
390         _dl_signal_error (0, map->l_name,
391                           "R_PPC_ADDR24 relocation out of range");
392       *reloc_addr = (*reloc_addr & 0xfc000003) | (finaladdr & 0x3fffffc);
393       break;
394
395     case R_PPC_ADDR16:
396     case R_PPC_UADDR16:
397       if (finaladdr > 0x7fff && finaladdr < 0x8000)
398         _dl_signal_error (0, map->l_name,
399                           "R_PPC_ADDR16 relocation out of range");
400       *(Elf32_Half*) reloc_addr = finaladdr;
401       break;
402
403     case R_PPC_ADDR16_LO:
404       *(Elf32_Half*) reloc_addr = finaladdr;
405       break;
406
407     case R_PPC_ADDR16_HI:
408       *(Elf32_Half*) reloc_addr = finaladdr >> 16;
409       break;
410
411     case R_PPC_ADDR16_HA:
412       *(Elf32_Half*) reloc_addr = (finaladdr + 0x8000) >> 16;
413       break;
414
415     case R_PPC_ADDR14:
416     case R_PPC_ADDR14_BRTAKEN:
417     case R_PPC_ADDR14_BRNTAKEN:
418       if (finaladdr > 0x7fff && finaladdr < 0x8000)
419         _dl_signal_error (0, map->l_name,
420                           "R_PPC_ADDR14 relocation out of range");
421       *reloc_addr = (*reloc_addr & 0xffff0003) | (finaladdr & 0xfffc);
422       if (rinfo != R_PPC_ADDR14)
423         *reloc_addr = ((*reloc_addr & 0xffdfffff)
424                        | ((rinfo == R_PPC_ADDR14_BRTAKEN)
425                           ^ (finaladdr >> 31)) << 21);
426       break;
427
428     case R_PPC_REL24:
429       {
430         Elf32_Sword delta = finaladdr - (Elf32_Word) reloc_addr;
431         if (delta << 6 >> 6 != delta)
432           _dl_signal_error (0, map->l_name,
433                             "R_PPC_REL24 relocation out of range");
434         *reloc_addr = (*reloc_addr & 0xfc000003) | (delta & 0x3fffffc);
435       }
436       break;
437
438     case R_PPC_COPY:
439       if (sym == NULL)
440         /* This can happen in trace mode when an object could not be
441            found.  */
442         return;
443       if (sym->st_size > refsym->st_size
444           || (_dl_verbose && sym->st_size < refsym->st_size))
445         {
446           const char *strtab;
447
448           strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
449           _dl_sysdep_error (_dl_argv[0] ?: "<program name unknown>",
450                             ": Symbol `", strtab + refsym->st_name,
451                             "' has different size in shared object, "
452                             "consider re-linking\n", NULL);
453         }
454       memcpy (reloc_addr, (char *) finaladdr, MIN (sym->st_size,
455                                                    refsym->st_size));
456       return;
457
458     case R_PPC_REL32:
459       *reloc_addr = finaladdr - (Elf32_Word) reloc_addr;
460       return;
461
462     case R_PPC_JMP_SLOT:
463       /* It used to be that elf_machine_fixup_plt was used here,
464          but that doesn't work when ld.so relocates itself
465          for the second time.  On the bright side, there's
466          no need to worry about thread-safety here.  */
467       {
468         Elf32_Sword delta = finaladdr - (Elf32_Word) reloc_addr;
469         if (delta << 6 >> 6 == delta)
470           *reloc_addr = OPCODE_B (delta);
471         else if (finaladdr <= 0x01fffffc || finaladdr >= 0xfe000000)
472           *reloc_addr = OPCODE_BA (finaladdr);
473         else
474           {
475             Elf32_Word *plt, *data_words;
476             Elf32_Word index, offset, num_plt_entries;
477             
478             plt = (Elf32_Word *) D_PTR (map, l_info[DT_PLTGOT]);
479             offset = reloc_addr - plt;
480
481             if (offset < PLT_DOUBLE_SIZE*2 + PLT_INITIAL_ENTRY_WORDS)
482               {
483                 index = (offset - PLT_INITIAL_ENTRY_WORDS)/2;
484                 num_plt_entries = (map->l_info[DT_PLTRELSZ]->d_un.d_val
485                                    / sizeof(Elf32_Rela));
486                 data_words = plt + PLT_DATA_START_WORDS (num_plt_entries);
487                 data_words[index] = finaladdr;
488                 reloc_addr[0] = OPCODE_LI (11, index * 4);
489                 reloc_addr[1] = OPCODE_B ((PLT_LONGBRANCH_ENTRY_WORDS 
490                                            - (offset+1)) 
491                                           * 4);
492                 MODIFIED_CODE_NOQUEUE (reloc_addr + 1);
493               }
494             else
495               {
496                 reloc_addr[0] = OPCODE_LIS_HI (12, finaladdr);
497                 reloc_addr[1] = OPCODE_ADDI (12, 12, finaladdr);
498                 reloc_addr[2] = OPCODE_MTCTR (12);
499                 reloc_addr[3] = OPCODE_BCTR ();
500                 MODIFIED_CODE_NOQUEUE (reloc_addr + 3);
501               }
502           }
503       }
504       break;
505
506     default:
507       _dl_reloc_bad_type (map, rinfo, 0);
508       return;
509     }
510
511   MODIFIED_CODE_NOQUEUE (reloc_addr);
512 }