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