1 /* $NetBSD: ppc_reloc.c,v 1.53 2014/08/25 20:40:52 joerg Exp $ */
2
3 /*-
4 * Copyright (C) 1998 Tsubai Masanari
5 * Portions copyright 2002 Charles M. Hannum <root@ihack.net>
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #include <sys/cdefs.h>
32 #ifndef lint
33 __RCSID("$NetBSD: ppc_reloc.c,v 1.53 2014/08/25 20:40:52 joerg Exp $");
34 #endif /* not lint */
35
36 #include <stdarg.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <sys/types.h>
41 #include <machine/cpu.h>
42
43 #include "debug.h"
44 #include "rtld.h"
45
46 void _rtld_powerpc_pltcall(Elf_Word);
47 void _rtld_powerpc_pltresolve(Elf_Word, Elf_Word);
48
49 #define __u64(x) ((uint64_t)(x))
50 #define __u32(x) ((uint32_t)(x))
51 #define __ha48 __u64(0xffffffff8000)
52 #define __ha32 __u64(0xffff8000)
53 #define __ha16 __u32(0x8000)
54 #define __ha(x,n) ((((x) >> (n)) + (((x) & __ha##n) == __ha##n)) & 0xffff)
55 #define __hi(x,n) (((x) >> (n)) & 0xffff)
56 #ifdef __LP64
57 #define highesta(x) __ha(__u64(x), 48)
58 #define highest(x) __hi(__u64(x), 48)
59 #define higher(x) __ha(__u64(x), 32)
60 #define higher(x) __hi(__u64(x), 32)
61 #endif
62 #define ha(x) __ha(__u32(x), 16)
63 #define hi(x) __hi(__u32(x), 16)
64 #define lo(x) (__u32(x) & 0xffff)
65
66 #ifdef _LP64
67 /* function descriptor for _rtld_bind_start */
68 extern const uint64_t _rtld_bind_start[3];
69 #else
70 void _rtld_bind_bssplt_start(void);
71 void _rtld_bind_secureplt_start(void);
72 #endif
73 Elf_Addr _rtld_bind(const Obj_Entry *, Elf_Word);
74 void _rtld_relocate_nonplt_self(Elf_Dyn *, Elf_Addr);
75 static int _rtld_relocate_plt_object(const Obj_Entry *,
76 const Elf_Rela *, int, Elf_Addr *);
77
78 /*
79 * The PPC32 PLT format consists of three sections:
80 * (1) The "pltcall" and "pltresolve" glue code. This is always 18 words.
81 * (2) The code part of the PLT entries. There are 2 words per entry for
82 * up to 8192 entries, then 4 words per entry for any additional entries.
83 * (3) The data part of the PLT entries, comprising a jump table.
84 * This section is half the size of the second section (ie. 1 or 2 words
85 * per entry).
86 */
87
88 void
_rtld_setup_pltgot(const Obj_Entry * obj)89 _rtld_setup_pltgot(const Obj_Entry *obj)
90 {
91 #ifdef _LP64
92 /*
93 * For powerpc64, just copy the function descriptor to pltgot[0].
94 */
95 if (obj->pltgot != NULL) {
96 obj->pltgot[0] = (Elf_Addr) _rtld_bind_start[0];
97 obj->pltgot[1] = (Elf_Addr) _rtld_bind_start[1];
98 obj->pltgot[2] = (Elf_Addr) obj;
99 }
100 #else
101 /*
102 * Secure-PLT is much more sane.
103 */
104 if (obj->gotptr != NULL) {
105 obj->gotptr[1] = (Elf_Addr) _rtld_bind_secureplt_start;
106 obj->gotptr[2] = (Elf_Addr) obj;
107 dbg(("obj %s secure-plt gotptr=%p start=%p obj=%p",
108 obj->path, obj->gotptr,
109 (void *) obj->gotptr[1], (void *) obj->gotptr[2]));
110 } else {
111 /*
112 * Setup the plt glue routines (for bss-plt).
113 */
114 #define BSSPLTCALL_SIZE 20
115 #define BSSPLTRESOLVE_SIZE 24
116
117 Elf_Word *pltcall, *pltresolve;
118 Elf_Word *jmptab;
119 int N = obj->pltrelalim - obj->pltrela;
120
121 /* Entries beyond 8192 take twice as much space. */
122 if (N > 8192)
123 N += N-8192;
124
125 dbg(("obj %s bss-plt pltgot=%p jmptab=%u start=%p obj=%p",
126 obj->path, obj->pltgot, 18 + N * 2,
127 _rtld_bind_bssplt_start, obj));
128
129 pltcall = obj->pltgot;
130 jmptab = pltcall + 18 + N * 2;
131
132 memcpy(pltcall, _rtld_powerpc_pltcall, BSSPLTCALL_SIZE);
133 pltcall[1] |= ha(jmptab);
134 pltcall[2] |= lo(jmptab);
135
136 pltresolve = obj->pltgot + 8;
137
138 memcpy(pltresolve, _rtld_powerpc_pltresolve, BSSPLTRESOLVE_SIZE);
139 pltresolve[0] |= ha(_rtld_bind_bssplt_start);
140 pltresolve[1] |= lo(_rtld_bind_bssplt_start);
141 pltresolve[3] |= ha(obj);
142 pltresolve[4] |= lo(obj);
143
144 /*
145 * Invalidate the icache for only the code part of the PLT
146 * (and not the jump table at the end).
147 */
148 __syncicache(pltcall, (char *)jmptab - (char *)pltcall);
149 }
150 #endif
151 }
152
153 void
_rtld_relocate_nonplt_self(Elf_Dyn * dynp,Elf_Addr relocbase)154 _rtld_relocate_nonplt_self(Elf_Dyn *dynp, Elf_Addr relocbase)
155 {
156 const Elf_Rela *rela = 0, *relalim;
157 Elf_Addr relasz = 0;
158 Elf_Addr *where;
159
160 for (; dynp->d_tag != DT_NULL; dynp++) {
161 switch (dynp->d_tag) {
162 case DT_RELA:
163 rela = (const Elf_Rela *)(relocbase + dynp->d_un.d_ptr);
164 break;
165 case DT_RELASZ:
166 relasz = dynp->d_un.d_val;
167 break;
168 }
169 }
170 relalim = (const Elf_Rela *)((const uint8_t *)rela + relasz);
171 for (; rela < relalim; rela++) {
172 where = (Elf_Addr *)(relocbase + rela->r_offset);
173 *where = (Elf_Addr)(relocbase + rela->r_addend);
174 }
175 }
176
177 int
_rtld_relocate_nonplt_objects(Obj_Entry * obj)178 _rtld_relocate_nonplt_objects(Obj_Entry *obj)
179 {
180 const Elf_Rela *rela;
181
182 for (rela = obj->rela; rela < obj->relalim; rela++) {
183 Elf_Addr *where;
184 const Elf_Sym *def;
185 const Obj_Entry *defobj;
186 Elf_Addr tmp;
187 unsigned long symnum;
188
189 where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
190 symnum = ELF_R_SYM(rela->r_info);
191
192 switch (ELF_R_TYPE(rela->r_info)) {
193 #if 1 /* XXX Should not be necessary. */
194 case R_TYPE(JMP_SLOT):
195 #endif
196 case R_TYPE(NONE):
197 break;
198
199 #ifdef _LP64
200 case R_TYPE(ADDR64): /* <address> S + A */
201 #else
202 case R_TYPE(ADDR32): /* <address> S + A */
203 #endif
204 case R_TYPE(GLOB_DAT): /* <address> S + A */
205 def = _rtld_find_symdef(symnum, obj, &defobj, false);
206 if (def == NULL)
207 return -1;
208
209 tmp = (Elf_Addr)(defobj->relocbase + def->st_value +
210 rela->r_addend);
211 if (*where != tmp)
212 *where = tmp;
213 rdbg(("32/GLOB_DAT %s in %s --> %p in %s",
214 obj->strtab + obj->symtab[symnum].st_name,
215 obj->path, (void *)*where, defobj->path));
216 break;
217
218 case R_TYPE(RELATIVE): /* <address> B + A */
219 *where = (Elf_Addr)(obj->relocbase + rela->r_addend);
220 rdbg(("RELATIVE in %s --> %p", obj->path,
221 (void *)*where));
222 break;
223
224 case R_TYPE(COPY):
225 /*
226 * These are deferred until all other relocations have
227 * been done. All we do here is make sure that the
228 * COPY relocation is not in a shared library. They
229 * are allowed only in executable files.
230 */
231 if (obj->isdynamic) {
232 _rtld_error(
233 "%s: Unexpected R_COPY relocation in shared library",
234 obj->path);
235 return -1;
236 }
237 rdbg(("COPY (avoid in main)"));
238 break;
239
240 case R_TYPE(DTPMOD):
241 def = _rtld_find_symdef(symnum, obj, &defobj, false);
242 if (def == NULL)
243 return -1;
244
245 *where = (Elf_Addr)defobj->tlsindex;
246 rdbg(("DTPMOD32 %s in %s --> %p in %s",
247 obj->strtab + obj->symtab[symnum].st_name,
248 obj->path, (void *)*where, defobj->path));
249 break;
250
251 case R_TYPE(DTPREL):
252 def = _rtld_find_symdef(symnum, obj, &defobj, false);
253 if (def == NULL)
254 return -1;
255
256 if (!defobj->tls_done && _rtld_tls_offset_allocate(obj))
257 return -1;
258
259 *where = (Elf_Addr)(def->st_value + rela->r_addend
260 - TLS_DTV_OFFSET);
261 rdbg(("DTPREL32 %s in %s --> %p in %s",
262 obj->strtab + obj->symtab[symnum].st_name,
263 obj->path, (void *)*where, defobj->path));
264 break;
265
266 case R_TYPE(TPREL):
267 def = _rtld_find_symdef(symnum, obj, &defobj, false);
268 if (def == NULL)
269 return -1;
270
271 if (!defobj->tls_done && _rtld_tls_offset_allocate(obj))
272 return -1;
273
274 *where = (Elf_Addr)(def->st_value + rela->r_addend
275 + defobj->tlsoffset - TLS_TP_OFFSET);
276 rdbg(("TPREL32 %s in %s --> %p in %s",
277 obj->strtab + obj->symtab[symnum].st_name,
278 obj->path, (void *)*where, defobj->path));
279 break;
280
281 default:
282 rdbg(("sym = %lu, type = %lu, offset = %p, "
283 "addend = %p, contents = %p, symbol = %s",
284 symnum, (u_long)ELF_R_TYPE(rela->r_info),
285 (void *)rela->r_offset, (void *)rela->r_addend,
286 (void *)*where,
287 obj->strtab + obj->symtab[symnum].st_name));
288 _rtld_error("%s: Unsupported relocation type %ld "
289 "in non-PLT relocations",
290 obj->path, (u_long) ELF_R_TYPE(rela->r_info));
291 return -1;
292 }
293 }
294 return 0;
295 }
296
297 int
_rtld_relocate_plt_lazy(const Obj_Entry * obj)298 _rtld_relocate_plt_lazy(const Obj_Entry *obj)
299 {
300 #ifdef _LP64
301 /*
302 * For PowerPC64, the plt stubs handle an empty function descriptor
303 * so there's nothing to do.
304 */
305 #else
306 Elf_Addr * const pltresolve = obj->pltgot + 8;
307 const Elf_Rela *rela;
308 int reloff;
309
310 for (rela = obj->pltrela, reloff = 0;
311 rela < obj->pltrelalim;
312 rela++, reloff++) {
313 Elf_Word *where = (Elf_Word *)(obj->relocbase + rela->r_offset);
314
315 assert(ELF_R_TYPE(rela->r_info) == R_TYPE(JMP_SLOT));
316
317 if (obj->gotptr != NULL) {
318 /*
319 * For now, simply treat then as relative.
320 */
321 *where += (Elf_Addr)obj->relocbase;
322 } else {
323 int distance;
324
325 if (reloff < 32768) {
326 /* li r11,reloff */
327 *where++ = 0x39600000 | reloff;
328 } else {
329 /* lis r11,ha(reloff) */
330 /* addi r11,lo(reloff) */
331 *where++ = 0x3d600000 | ha(reloff);
332 *where++ = 0x396b0000 | lo(reloff);
333 }
334 /* b pltresolve */
335 distance = (Elf_Addr)pltresolve - (Elf_Addr)where;
336 *where++ = 0x48000000 | (distance & 0x03fffffc);
337
338 /*
339 * Icache invalidation is not done for each entry here
340 * because we sync the entire code part of the PLT once
341 * in _rtld_setup_pltgot() after all the entries have been
342 * initialized.
343 */
344 /* __syncicache(where - 3, 12); */
345 }
346 }
347 #endif /* !_LP64 */
348
349 return 0;
350 }
351
352 static int
_rtld_relocate_plt_object(const Obj_Entry * obj,const Elf_Rela * rela,int reloff,Elf_Addr * tp)353 _rtld_relocate_plt_object(const Obj_Entry *obj, const Elf_Rela *rela, int reloff, Elf_Addr *tp)
354 {
355 Elf_Word *where = (Elf_Word *)(obj->relocbase + rela->r_offset);
356 Elf_Addr value;
357 const Elf_Sym *def;
358 const Obj_Entry *defobj;
359 unsigned long info = rela->r_info;
360
361 assert(ELF_R_TYPE(info) == R_TYPE(JMP_SLOT));
362
363 def = _rtld_find_plt_symdef(ELF_R_SYM(info), obj, &defobj, tp != NULL);
364 if (__predict_false(def == NULL))
365 return -1;
366 if (__predict_false(def == &_rtld_sym_zero))
367 return 0;
368
369 if (ELF_ST_TYPE(def->st_info) == STT_GNU_IFUNC) {
370 if (tp == NULL)
371 return 0;
372 value = _rtld_resolve_ifunc(defobj, def);
373 } else {
374 value = (Elf_Addr)(defobj->relocbase + def->st_value);
375 }
376 rdbg(("bind now/fixup in %s --> new=%p",
377 defobj->strtab + def->st_name, (void *)value));
378
379 #ifdef _LP64
380 /*
381 * For PowerPC64 we simply replace the function descriptor in the
382 * PLTGOT with the one from source object.
383 */
384 assert(where >= (Elf_Word *)obj->pltgot);
385 assert(where < (Elf_Word *)obj->pltgot + (obj->pltrelalim - obj->pltrela));
386 const Elf_Addr * const fdesc = (Elf_Addr *) value;
387 where[0] = fdesc[0];
388 where[1] = fdesc[1];
389 where[2] = fdesc[2];
390 #else
391 ptrdiff_t distance = value - (Elf_Addr)where;
392 if (obj->gotptr != NULL) {
393 /*
394 * For Secure-PLT we simply replace the entry in GOT with the
395 * address of the routine.
396 */
397 assert(where >= (Elf_Word *)obj->pltgot);
398 assert(where < (Elf_Word *)obj->pltgot + (obj->pltrelalim - obj->pltrela));
399 *where = value;
400 } else if (labs(distance) < 32*1024*1024) { /* inside 32MB? */
401 /* b value # branch directly */
402 *where = 0x48000000 | (distance & 0x03fffffc);
403 __syncicache(where, 4);
404 } else {
405 Elf_Addr *pltcall, *jmptab;
406 int N = obj->pltrelalim - obj->pltrela;
407
408 /* Entries beyond 8192 take twice as much space. */
409 if (N > 8192)
410 N += N-8192;
411
412 pltcall = obj->pltgot;
413 jmptab = pltcall + 18 + N * 2;
414
415 jmptab[reloff] = value;
416
417 if (reloff < 32768) {
418 /* li r11,reloff */
419 *where++ = 0x39600000 | reloff;
420 } else {
421 #ifdef notyet
422 /* lis r11,ha(value) */
423 /* addi r11,lo(value) */
424 /* mtctr r11 */
425 /* bctr */
426 *where++ = 0x3d600000 | ha(value);
427 *where++ = 0x396b0000 | lo(value);
428 *where++ = 0x7d6903a6;
429 *where++ = 0x4e800420;
430 #else
431 /* lis r11,ha(reloff) */
432 /* addi r11,lo(reloff) */
433 *where++ = 0x3d600000 | ha(reloff);
434 *where++ = 0x396b0000 | lo(reloff);
435 #endif
436 }
437 /* b pltcall */
438 distance = (Elf_Addr)pltcall - (Elf_Addr)where;
439 *where++ = 0x48000000 | (distance & 0x03fffffc);
440 __syncicache(where - 3, 12);
441 }
442 #endif /* _LP64 */
443
444 if (tp)
445 *tp = value;
446 return 0;
447 }
448
449 Elf_Addr
_rtld_bind(const Obj_Entry * obj,Elf_Word reloff)450 _rtld_bind(const Obj_Entry *obj, Elf_Word reloff)
451 {
452 const Elf_Rela *rela = obj->pltrela + reloff;
453 Elf_Addr new_value;
454 int err;
455
456 new_value = 0; /* XXX gcc */
457
458 _rtld_shared_enter();
459 err = _rtld_relocate_plt_object(obj, rela, reloff, &new_value);
460 if (err)
461 _rtld_die();
462 _rtld_shared_exit();
463
464 #ifdef _LP64
465 return obj->glink;
466 #else
467 return new_value;
468 #endif
469 }
470
471 int
_rtld_relocate_plt_objects(const Obj_Entry * obj)472 _rtld_relocate_plt_objects(const Obj_Entry *obj)
473 {
474 const Elf_Rela *rela;
475 int reloff;
476
477 for (rela = obj->pltrela, reloff = 0; rela < obj->pltrelalim; rela++, reloff++) {
478 if (_rtld_relocate_plt_object(obj, rela, reloff, NULL) < 0)
479 return -1;
480 }
481 return 0;
482 }
483