1 /*
2 * Copyright 2011-2012, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef ELF_OBJECT_HXX
18 #define ELF_OBJECT_HXX
19
20 #include <android/log.h>
21
22 #include "ELFHeader.h"
23 #include "ELFReloc.h"
24 #include "ELFSection.h"
25 #include "ELFSectionHeaderTable.h"
26 #include "StubLayout.h"
27 #include "GOT.h"
28 #include "ELF.h"
29
30 #include <llvm/ADT/SmallVector.h>
31
32 #include "utils/rsl_assert.h"
33
34
35 template <unsigned Bitwidth>
36 template <typename Archiver>
37 inline ELFObject<Bitwidth> *
read(Archiver & AR)38 ELFObject<Bitwidth>::read(Archiver &AR) {
39 std::unique_ptr<ELFObjectTy> object(new ELFObjectTy());
40
41 // Read header
42 object->header.reset(ELFHeaderTy::read(AR));
43 if (!object->header) {
44 return 0;
45 }
46
47 // Read section table
48 object->shtab.reset(ELFSectionHeaderTableTy::read(AR, object.get()));
49 if (!object->shtab) {
50 return 0;
51 }
52
53 // Read each section
54 llvm::SmallVector<size_t, 4> progbits_ndx;
55 for (size_t i = 0; i < object->header->getSectionHeaderNum(); ++i) {
56 if ((*object->shtab)[i]->getType() == SHT_PROGBITS) {
57 object->stab.push_back(NULL);
58 progbits_ndx.push_back(i);
59 } else {
60 std::unique_ptr<ELFSectionTy> sec(
61 ELFSectionTy::read(AR, object.get(), (*object->shtab)[i]));
62 object->stab.push_back(sec.release());
63 }
64 }
65
66 object->shtab->buildNameMap();
67 ELFSectionSymTabTy *symtab =
68 static_cast<ELFSectionSymTabTy *>(object->getSectionByName(".symtab"));
69 rsl_assert(symtab && "Symtab is required.");
70 symtab->buildNameMap();
71
72 for (size_t i = 0; i < progbits_ndx.size(); ++i) {
73 size_t index = progbits_ndx[i];
74
75 std::unique_ptr<ELFSectionTy> sec(
76 ELFSectionTy::read(AR, object.get(), (*object->shtab)[index]));
77 object->stab[index] = sec.release();
78 }
79
80 return object.release();
81 }
82
83 template <unsigned Bitwidth>
getSectionName(size_t i) const84 inline char const *ELFObject<Bitwidth>::getSectionName(size_t i) const {
85 ELFSectionTy const *sec = stab[header->getStringSectionIndex()];
86
87 if (sec) {
88 ELFSectionStrTabTy const &st =
89 static_cast<ELFSectionStrTabTy const &>(*sec);
90 return st[i];
91 }
92
93 return NULL;
94 }
95
96 template <unsigned Bitwidth>
97 inline ELFSection<Bitwidth> const *
getSectionByIndex(size_t i) const98 ELFObject<Bitwidth>::getSectionByIndex(size_t i) const {
99 return stab[i];
100 }
101
102 template <unsigned Bitwidth>
103 inline ELFSection<Bitwidth> *
getSectionByIndex(size_t i)104 ELFObject<Bitwidth>::getSectionByIndex(size_t i) {
105 return stab[i];
106 }
107
108 template <unsigned Bitwidth>
109 inline ELFSection<Bitwidth> const *
getSectionByName(std::string const & str) const110 ELFObject<Bitwidth>::getSectionByName(std::string const &str) const {
111 size_t idx = getSectionHeaderTable()->getByName(str)->getIndex();
112 return stab[idx];
113 }
114
115 template <unsigned Bitwidth>
116 inline ELFSection<Bitwidth> *
getSectionByName(std::string const & str)117 ELFObject<Bitwidth>::getSectionByName(std::string const &str) {
118 ELFObjectTy const *const_this = this;
119 ELFSectionTy const *sptr = const_this->getSectionByName(str);
120 // Const cast for the same API's const and non-const versions.
121 return const_cast<ELFSectionTy *>(sptr);
122 }
123
124
125 template <unsigned Bitwidth>
126 inline void ELFObject<Bitwidth>::
relocateARM(void * (* find_sym)(void * context,char const * name),void * context,ELFSectionRelTableTy * reltab,ELFSectionProgBitsTy * text)127 relocateARM(void *(*find_sym)(void *context, char const *name),
128 void *context,
129 ELFSectionRelTableTy *reltab,
130 ELFSectionProgBitsTy *text) {
131 // FIXME: Should be implement in independent files.
132 rsl_assert(Bitwidth == 32 && "ARM only have 32 bits.");
133
134 ELFSectionSymTabTy *symtab =
135 static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
136 rsl_assert(symtab && "Symtab is required.");
137
138 for (size_t i = 0; i < reltab->size(); ++i) {
139 // FIXME: Can not implement here, use Fixup!
140 ELFRelocTy *rel = (*reltab)[i];
141 ELFSymbolTy *sym = (*symtab)[rel->getSymTabIndex()];
142
143 // FIXME: May be not uint32_t *.
144 typedef int32_t Inst_t;
145 Inst_t *inst = (Inst_t *)&(*text)[rel->getOffset()];
146 Inst_t P = (Inst_t)(int64_t)inst;
147 Inst_t A = 0;
148 Inst_t S = (Inst_t)(int64_t)sym->getAddress(EM_ARM);
149 Inst_t T = 0;
150
151 if (sym->isConcreteFunc() && (sym->getValue() & 0x1)) {
152 T = 1;
153 }
154 relinfo_t reltype = rel->getType();
155 switch (reltype) {
156 default:
157 rsl_assert(0 && "Not implemented relocation type.");
158 break;
159
160 case R_ARM_ABS32:
161 {
162 if (S == 0 && sym->getType() == STT_NOTYPE) {
163 void *ext_sym = find_sym(context, sym->getName());
164 if (!ext_sym) {
165 missingSymbols = true;
166 }
167 S = (Inst_t)(uintptr_t)ext_sym;
168 sym->setAddress(ext_sym);
169 }
170 A = *inst;
171 *inst = (S + A) | T;
172 }
173 break;
174
175 // FIXME: Predefine relocation codes.
176 case R_ARM_CALL:
177 case R_ARM_THM_CALL:
178 case R_ARM_JUMP24:
179 case R_ARM_THM_JUMP24:
180 {
181 #define SIGN_EXTEND(x, l) (((x)^(1<<((l)-1)))-(1<<(l-1)))
182 if (reltype == R_ARM_CALL || reltype == R_ARM_JUMP24) {
183 A = (Inst_t)(int64_t)SIGN_EXTEND(*inst & 0xFFFFFF, 24);
184 A <<= 2;
185 } else {
186 // Hack for two 16bit.
187 *inst = ((*inst >> 16) & 0xFFFF) | (*inst << 16);
188 Inst_t s = (*inst >> 26) & 0x1u, // 26
189 u = (*inst >> 16) & 0x3FFu, // 25-16
190 l = *inst & 0x7FFu, // 10-0
191 j1 = (*inst >> 13) & 0x1u, // 13
192 j2 = (*inst >> 11) & 0x1u; // 11
193 Inst_t i1 = (~(j1 ^ s)) & 0x1u,
194 i2 = (~(j2 ^ s)) & 0x1u;
195 // [31-25][24][23][22][21-12][11-1][0]
196 // 0 s i1 i2 u l 0
197 A = SIGN_EXTEND((s << 23) | (i1 << 22) | (i2 << 21) | (u << 11) | l, 24);
198 A <<= 1;
199 }
200 #undef SIGN_EXTEND
201
202 void *callee_addr = sym->getAddress(EM_ARM);
203
204 switch (sym->getType()) {
205 default:
206 rsl_assert(0 && "Wrong type for R_ARM_CALL relocation.");
207 abort();
208 break;
209
210 case STT_FUNC:
211 // NOTE: Callee function is in the object file, but it may be
212 // in different PROGBITS section (which may be far call).
213
214 if (callee_addr == 0) {
215 rsl_assert(0 && "We should get function address at previous "
216 "sym->getAddress(EM_ARM) function call.");
217 abort();
218 }
219 break;
220
221 case STT_NOTYPE:
222 // NOTE: Callee function is an external function. Call find_sym
223 // if it has not resolved yet.
224
225 if (callee_addr == 0) {
226 callee_addr = find_sym(context, sym->getName());
227 if (!callee_addr) {
228 missingSymbols = true;
229 }
230 sym->setAddress(callee_addr);
231 }
232 break;
233 }
234
235 // Get the stub for this function
236 StubLayout *stub_layout = text->getStubLayout();
237
238 if (!stub_layout) {
239 llvm::errs() << "unable to get stub layout." << "\n";
240 abort();
241 }
242
243 void *stub = stub_layout->allocateStub(callee_addr);
244
245 if (!stub) {
246 llvm::errs() << "unable to allocate stub." << "\n";
247 abort();
248 }
249
250 //LOGI("Function %s: using stub %p\n", sym->getName(), stub);
251 S = (uint32_t)(uintptr_t)stub;
252
253 if (reltype == R_ARM_CALL || reltype == R_ARM_JUMP24) {
254 // Relocate the R_ARM_CALL relocation type
255 uint32_t result = (S + A - P) >> 2;
256
257 if (result > 0x007FFFFF && result < 0xFF800000) {
258 rsl_assert(0 && "Stub is still too far");
259 abort();
260 }
261
262 *inst = ((result) & 0x00FFFFFF) | (*inst & 0xFF000000);
263 } else {
264 P &= ~0x3; // Base address align to 4 bytes. (For BLX.)
265
266 // Relocate the R_ARM_THM_CALL relocation type
267 uint32_t result = (S + A - P) >> 1;
268
269 if (result > 0x007FFFFF && result < 0xFF800000) {
270 rsl_assert(0 && "Stub is still too far");
271 abort();
272 }
273
274 //*inst &= 0xF800D000u;
275 // Rewrite instruction to BLX. (Stub is always ARM.)
276 *inst &= 0xF800C000u;
277 // [31-25][24][23][22][21-12][11-1][0]
278 // 0 s i1 i2 u l 0
279 Inst_t s = (result >> 23) & 0x1u, // 26
280 u = (result >> 11) & 0x3FFu, // 25-16
281 // For BLX, bit [0] is 0.
282 l = result & 0x7FEu, // 10-0
283 i1 = (result >> 22) & 0x1u,
284 i2 = (result >> 21) & 0x1u;
285 Inst_t j1 = ((~i1) ^ s) & 0x01u, // 13
286 j2 = ((~i2) ^ s) & 0x01u; // 11
287 *inst |= s << 26;
288 *inst |= u << 16;
289 *inst |= l;
290 *inst |= j1 << 13;
291 *inst |= j2 << 11;
292 // Hack for two 16bit.
293 *inst = ((*inst >> 16) & 0xFFFF) | (*inst << 16);
294 }
295 }
296 break;
297 case R_ARM_MOVT_ABS:
298 case R_ARM_MOVW_ABS_NC:
299 case R_ARM_THM_MOVW_ABS_NC:
300 case R_ARM_THM_MOVT_ABS:
301 {
302 if (S == 0 && sym->getType() == STT_NOTYPE) {
303 void *ext_sym = find_sym(context, sym->getName());
304 if (!ext_sym) {
305 missingSymbols = true;
306 }
307 S = (Inst_t)(uintptr_t)ext_sym;
308 sym->setAddress(ext_sym);
309 }
310 if (reltype == R_ARM_MOVT_ABS
311 || reltype == R_ARM_THM_MOVT_ABS) {
312 S >>= 16;
313 }
314
315 if (reltype == R_ARM_MOVT_ABS
316 || reltype == R_ARM_MOVW_ABS_NC) {
317 // No need sign extend.
318 A = ((*inst & 0xF0000) >> 4) | (*inst & 0xFFF);
319 uint32_t result = (S + A);
320 *inst = (((result) & 0xF000) << 4) |
321 ((result) & 0xFFF) |
322 (*inst & 0xFFF0F000);
323 } else {
324 // Hack for two 16bit.
325 *inst = ((*inst >> 16) & 0xFFFF) | (*inst << 16);
326 // imm16: [19-16][26][14-12][7-0]
327 A = (((*inst >> 4) & 0xF000u) |
328 ((*inst >> 15) & 0x0800u) |
329 ((*inst >> 4) & 0x0700u) |
330 ( *inst & 0x00FFu));
331 uint32_t result;
332 if (reltype == R_ARM_THM_MOVT_ABS) {
333 result = (S + A);
334 } else {
335 result = (S + A) | T;
336 }
337 // imm16: [19-16][26][14-12][7-0]
338 *inst &= 0xFBF08F00u;
339 *inst |= (result & 0xF000u) << 4;
340 *inst |= (result & 0x0800u) << 15;
341 *inst |= (result & 0x0700u) << 4;
342 *inst |= (result & 0x00FFu);
343 // Hack for two 16bit.
344 *inst = ((*inst >> 16) & 0xFFFF) | (*inst << 16);
345 }
346 }
347 break;
348 }
349 //llvm::errs() << "S: " << (void *)S << '\n';
350 //llvm::errs() << "A: " << (void *)A << '\n';
351 //llvm::errs() << "P: " << (void *)P << '\n';
352 //llvm::errs() << "S+A: " << (void *)(S+A) << '\n';
353 //llvm::errs() << "S+A-P: " << (void *)(S+A-P) << '\n';
354 }
355 }
356
357 template <unsigned Bitwidth>
358 inline void ELFObject<Bitwidth>::
relocateAARCH64(void * (* find_sym)(void * context,char const * name),void * context,ELFSectionRelTableTy * reltab,ELFSectionProgBitsTy * text)359 relocateAARCH64(void *(*find_sym)(void *context, char const *name),
360 void *context,
361 ELFSectionRelTableTy *reltab,
362 ELFSectionProgBitsTy *text) {
363 // FIXME: Should be implement in independent files.
364 rsl_assert(Bitwidth == 64 && "AARCH64 only have 64 bits.");
365
366 // Change this to true to enable some debugging in the log.
367 const bool kDebugSymbolPrint = false;
368
369 ELFSectionSymTabTy *symtab =
370 static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
371 rsl_assert(symtab && "Symtab is required.");
372
373 for (size_t i = 0; i < reltab->size(); ++i) {
374 ELFRelocTy *rel = (*reltab)[i];
375 ELFSymbolTy *sym = (*symtab)[rel->getSymTabIndex()];
376
377 typedef int64_t Inst_t;
378 Inst_t *inst = (Inst_t *)&(*text)[rel->getOffset()];
379 int32_t* inst32 = reinterpret_cast<int32_t*>(inst);
380 int16_t* inst16 = reinterpret_cast<int16_t*>(inst);
381 Inst_t P = (Inst_t)(int64_t)inst;
382 Inst_t A = 0;
383 Inst_t S = (Inst_t)(int64_t)sym->getAddress(EM_ARM);
384 Inst_t Page_P = P & ~0xfff; // Page address.
385
386 if (S == 0 && sym->getType() == STT_NOTYPE) {
387 void *ext_sym = find_sym(context, sym->getName());
388 if (!ext_sym) {
389 missingSymbols = true;
390 }
391 S = (Inst_t)(uintptr_t)ext_sym;
392 sym->setAddress(ext_sym);
393 }
394
395 if (kDebugSymbolPrint) {
396 __android_log_print(ANDROID_LOG_INFO, "rs", "AARCH64 relocation symbol %s value is %llx\n",
397 sym->getName(), (unsigned long long)S);
398 }
399
400 // TODO: add other relocations when we know what ones are used.
401 relinfo_t reltype = rel->getType();
402 switch (reltype) {
403 default:
404 __android_log_print(ANDROID_LOG_ERROR, "rs",
405 "Unimplemented AARCH64 relocation type %d(0x%x)\n", static_cast<uint32_t>(reltype),
406 static_cast<uint32_t>(reltype));
407 rsl_assert(0 && "Unimplemented relocation type.");
408 break;
409
410 case R_AARCH64_ABS64:
411 A = *inst + rel->getAddend();
412 *inst = S + A;
413 break;
414
415 case R_AARCH64_ABS32:
416 A = *inst + rel->getAddend();
417 *inst32 = static_cast<int32_t>(S + A);
418 break;
419
420 case R_AARCH64_ABS16:
421 A = *inst + rel->getAddend();
422 *inst16 = static_cast<int16_t>(S + A);
423 break;
424
425 case R_AARCH64_PREL64:
426 A = *inst + rel->getAddend();
427 *inst = S + A - P;
428 break;
429
430 case R_AARCH64_PREL32:
431 A = *inst32 + rel->getAddend();
432 *inst32 = static_cast<int32_t>(S + A - P);
433 break;
434
435 case R_AARCH64_PREL16:
436 A = *inst16 + rel->getAddend();
437 *inst16 = static_cast<int16_t>(S + A - P);
438 break;
439
440 case R_AARCH64_ADR_PREL_PG_HI21:
441 // Relocate an ADRP instruction to the page
442 {
443 A = rel->getAddend();
444 int32_t immed = ((S + A) & ~0xfff) - Page_P;
445 immed >>= 12;
446 uint32_t immlo = immed & 0b11; // 2 bits.
447 uint32_t immhi = (immed >> 2) & 0x7FFFF; // 19 bits.
448 *inst32 |= static_cast<int32_t>(immlo << 29 | immhi << 5);
449 }
450 break;
451
452 case R_AARCH64_ADR_PREL_LO21:
453 {
454 A = rel->getAddend();
455 int32_t immed = S + A - P;
456 uint32_t immlo = immed & 0b11; // 2 bits.
457 uint32_t immhi = (immed >> 2) & 0x7FFFF; // 19 bits.
458 *inst32 |= static_cast<int32_t>(immlo << 29 | immhi << 5);
459 }
460 break;
461
462 case R_AARCH64_ADD_ABS_LO12_NC:
463 // ADD instruction immediate value.
464 {
465 A = rel->getAddend();
466 int32_t immed = S + A;
467 uint32_t imm12 = (immed & 0xFFF); // 12 bits.
468 *inst32 |= static_cast<int32_t>(imm12 << 10);
469 }
470 break;
471
472 case R_AARCH64_LDST8_ABS_LO12_NC:
473 case R_AARCH64_LDST16_ABS_LO12_NC:
474 case R_AARCH64_LDST32_ABS_LO12_NC:
475 case R_AARCH64_LDST64_ABS_LO12_NC:
476 case R_AARCH64_LDST128_ABS_LO12_NC:
477 {
478 // Set LD/ST (unsigned) immediate instruction to the low 12 bits, shifted depending
479 // on relocation.
480 A = rel->getAddend();
481 uint32_t shift = 0;
482 switch (reltype) {
483 case R_AARCH64_LDST8_ABS_LO12_NC: shift = 0; break;
484 case R_AARCH64_LDST16_ABS_LO12_NC: shift = 1; break;
485 case R_AARCH64_LDST32_ABS_LO12_NC: shift = 2; break;
486 case R_AARCH64_LDST64_ABS_LO12_NC: shift = 3; break;
487 case R_AARCH64_LDST128_ABS_LO12_NC: shift = 4; break;
488 default:
489 rsl_assert("Cannot reach");
490 }
491
492 // Form imm12 by taking 12 bits and shifting by appropriate amount.
493 uint32_t imm12 = ((S + A) & 0xFFF) >> shift;
494
495 // Put it into the instruction.
496 *inst32 |= static_cast<int32_t>(imm12 << 10);
497 }
498 break;
499
500 case R_AARCH64_CALL26:
501 case R_AARCH64_JUMP26:
502 {
503 #define SIGN_EXTEND(x, l) (((x)^(1<<((l)-1)))-(1<<(l-1)))
504 A = (Inst_t)(int64_t)SIGN_EXTEND(*inst32 & 0x3FFFFFF, 26);
505 A <<= 2;
506 #undef SIGN_EXTEND
507
508 void *callee_addr = sym->getAddress(EM_AARCH64);
509 bool call_via_stub = false; // Call via a stub (linker veneer).
510
511 switch (sym->getType()) {
512 default:
513 rsl_assert(0 && "Wrong type for R_ARM_CALL relocation.");
514 abort();
515 break;
516
517 case STT_FUNC:
518 // NOTE: Callee function is in the object file, but it may be
519 // in different PROGBITS section (which may be far call).
520
521 if (callee_addr == 0) {
522 rsl_assert(0 && "We should get function address at previous "
523 "sym->getAddress(EM_ARM) function call.");
524 abort();
525 }
526 break;
527
528 case STT_NOTYPE:
529 // NOTE: Callee function is an external function. Call find_sym
530 // if it has not resolved yet.
531
532 if (callee_addr == 0) {
533 callee_addr = find_sym(context, sym->getName());
534 if (!callee_addr) {
535 missingSymbols = true;
536 }
537 sym->setAddress(callee_addr);
538 }
539 break;
540 }
541
542 S = reinterpret_cast<int64_t>(callee_addr);
543 uint32_t result = (S + A - P) >> 2;
544
545 // See if we can do the branch without a stub.
546 if (result > 0x01FFFFFF && result < 0xFE000000) {
547 // Not in range, need a stub.
548 call_via_stub = true;
549 }
550
551 // Calling via a stub makes a BL instruction to a stub containing the following code:
552 // ldr x16, addr
553 // br x16
554 // addr:
555 // .word low32
556 // .word high32
557 //
558 // This loads the PC value from the 64 bits at PC + 8. Since AARCH64 can't
559 // manipulate the PC directly we have to load a register and branch to the contents.
560 if (call_via_stub) {
561 // Get the stub for this function
562 StubLayout *stub_layout = text->getStubLayout();
563
564 if (!stub_layout) {
565 __android_log_print(ANDROID_LOG_ERROR, "rs", "unable to get stub layout\n");
566 llvm::errs() << "unable to get stub layout." << "\n";
567 abort();
568 }
569
570 void *stub = stub_layout->allocateStub(callee_addr);
571
572 if (!stub) {
573 __android_log_print(ANDROID_LOG_ERROR, "rs", "unable to allocate stub\n");
574 llvm::errs() << "unable to allocate stub." << "\n";
575 abort();
576 }
577
578 //LOGI("Function %s: using stub %p\n", sym->getName(), stub);
579 S = (uint64_t)(uintptr_t)stub;
580
581 result = (S + A - P) >> 2;
582
583 if (result > 0x01FFFFFF && result < 0xFE000000) {
584 __android_log_print(ANDROID_LOG_ERROR, "rs", "stub is still too far\n");
585 rsl_assert(0 && "Stub is still too far");
586 abort();
587 }
588 }
589
590 // 'result' contains the offset from PC to the destination address, encoded
591 // in the correct form for the BL or B instructions.
592 *inst32 = (result & 0x03FFFFFF) | (*inst & 0xFC000000);
593 }
594 break;
595 case R_AARCH64_MOVW_UABS_G0:
596 case R_AARCH64_MOVW_UABS_G0_NC:
597 case R_AARCH64_MOVW_UABS_G1:
598 case R_AARCH64_MOVW_UABS_G1_NC:
599 case R_AARCH64_MOVW_UABS_G2:
600 case R_AARCH64_MOVW_UABS_G2_NC:
601 case R_AARCH64_MOVW_UABS_G3:
602 {
603 int shift = 0;
604 switch (reltype) {
605 case R_AARCH64_MOVW_UABS_G0:
606 case R_AARCH64_MOVW_UABS_G0_NC: shift = 0; break;
607 case R_AARCH64_MOVW_UABS_G1:
608 case R_AARCH64_MOVW_UABS_G1_NC: shift = 16; break;
609 case R_AARCH64_MOVW_UABS_G2:
610 case R_AARCH64_MOVW_UABS_G2_NC: shift = 32; break;
611 case R_AARCH64_MOVW_UABS_G3: shift = 48; break;
612 }
613
614 A = (*inst32 >> 5) & 0xFFFF;
615 uint32_t value = ((S + A) >> shift) & 0xFFFF;
616 *inst32 = (*inst32 & ~(0xFFFF << 6)) | (value << 6);
617 }
618 break;
619
620 case R_AARCH64_MOVW_SABS_G0:
621 case R_AARCH64_MOVW_SABS_G1:
622 case R_AARCH64_MOVW_SABS_G2:
623 {
624 int shift = 0;
625 switch (reltype) {
626 case R_AARCH64_MOVW_SABS_G0: shift = 0; break;
627 case R_AARCH64_MOVW_SABS_G1: shift = 16; break;
628 case R_AARCH64_MOVW_SABS_G2: shift = 32; break;
629 }
630
631 A = (*inst32 >> 5) & 0xFFFF;
632 int32_t value = ((S + A) >> shift) & 0xFFFF;
633
634 *inst32 = (*inst32 & ~(0xFFFF << 6)) | (value << 6);
635
636 // This relocation type must also set the instruction bit 30 to 0 or 1
637 // depending on the sign of the value. The bit corresponds to the
638 // movz or movn encoding. A value of 0 means movn.
639 if (value >= 0) {
640 // Set the instruction to movz (set bit 30 to 1)
641 *inst32 |= 0x40000000;
642 } else {
643 // Set the instruction to movn (set bit 30 to 0)
644 *inst32 &= ~0x40000000;
645 }
646 }
647 break;
648 }
649 //llvm::errs() << "S: " << (void *)S << '\n';
650 //llvm::errs() << "A: " << (void *)A << '\n';
651 //llvm::errs() << "P: " << (void *)P << '\n';
652 //llvm::errs() << "S+A: " << (void *)(S+A) << '\n';
653 //llvm::errs() << "S+A-P: " << (void *)(S+A-P) << '\n';
654 }
655 }
656
657 template <unsigned Bitwidth>
658 inline void ELFObject<Bitwidth>::
relocateX86_64(void * (* find_sym)(void * context,char const * name),void * context,ELFSectionRelTableTy * reltab,ELFSectionProgBitsTy * text)659 relocateX86_64(void *(*find_sym)(void *context, char const *name),
660 void *context,
661 ELFSectionRelTableTy *reltab,
662 ELFSectionProgBitsTy *text) {
663 rsl_assert(Bitwidth == 64 && "Only support X86_64.");
664
665 ELFSectionSymTabTy *symtab =
666 static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
667 rsl_assert(symtab && "Symtab is required.");
668
669 for (size_t i = 0; i < reltab->size(); ++i) {
670 // FIXME: Can not implement here, use Fixup!
671 ELFRelocTy *rel = (*reltab)[i];
672 ELFSymbolTy *sym = (*symtab)[rel->getSymTabIndex()];
673
674 typedef intptr_t Inst_t;
675 Inst_t *inst = (Inst_t*)&(*text)[rel->getOffset()];
676 Inst_t P = (Inst_t)inst;
677 Inst_t A = (Inst_t)rel->getAddend();
678 Inst_t S = (Inst_t)sym->getAddress(EM_X86_64);
679
680 if (S == 0) {
681 S = (Inst_t)find_sym(context, sym->getName());
682 if (!S) {
683 missingSymbols = true;
684 }
685 sym->setAddress((void *)S);
686 }
687
688 switch (rel->getType()) {
689 default:
690 rsl_assert(0 && "Not implemented relocation type.");
691 break;
692
693 // FIXME, consider other relocation types if RS support dynamic reolcations in future.
694 case R_X86_64_64: {//Direct 64-bit.
695 int64_t *paddr = (int64_t*)&(*text)[rel->getOffset()];
696 int64_t vAddr = S + A;
697 *paddr = vAddr;
698 break;
699 }
700 case R_X86_64_PC32: {//PC relative 32-bit signed.
701 int32_t *paddr = (int32_t*)&(*text)[rel->getOffset()];
702 int64_t vOffset = S + A - P;
703
704 if (vOffset > INT32_MAX || vOffset < INT32_MIN) {
705 // Not in range, need a stub.
706 StubLayout *stub_layout = text->getStubLayout();
707 if (!stub_layout) {
708 __android_log_print(ANDROID_LOG_ERROR, "rs", "unable to get stub layout\n");
709 llvm::errs() << "unable to get stub layout." << "\n";
710 abort();
711 }
712
713 void *stub = stub_layout->allocateStub((void *)S);
714
715 if (!stub) {
716 __android_log_print(ANDROID_LOG_ERROR, "rs", "unable to allocate stub\n");
717 llvm::errs() << "unable to allocate stub." << "\n";
718 abort();
719 }
720
721 S = (Inst_t)stub;
722 vOffset = S + A - P;
723
724 if (vOffset > INT32_MAX || vOffset < INT32_MIN) {
725 __android_log_print(ANDROID_LOG_ERROR, "rs", "stub is still too far\n");
726 rsl_assert(0 && "Stub is still too far");
727 abort();
728 }
729 }
730
731 rsl_assert(vOffset <= INT32_MAX && vOffset >= INT32_MIN);
732 *paddr = (int32_t)(vOffset & 0xFFFFFFFF);
733 break;
734 }
735 case R_X86_64_32: {//Direct 32-bit zero-extended.
736 uint32_t *paddr = (uint32_t*)&(*text)[rel->getOffset()];
737 int64_t vAddr = S + A;
738 rsl_assert(vAddr <= UINT32_MAX);
739 *paddr = (uint32_t)(vAddr & 0xFFFFFFFF);
740 break;
741 }
742 case R_X86_64_32S: {//Direct 32-bit sign-extended.
743 int32_t *paddr = (int32_t*)&(*text)[rel->getOffset()];
744 int64_t vAddr = S + A;
745 rsl_assert(vAddr <= INT32_MAX && vAddr >= INT32_MIN);
746 *paddr = (uint32_t)(vAddr & 0xFFFFFFFF);
747 break;
748 }
749 case R_X86_64_16: {//Direct 16-bit zero-extended.
750 uint16_t *paddr = (uint16_t*)&(*text)[rel->getOffset()];
751 int64_t vAddr = S + A;
752 rsl_assert(vAddr <= UINT16_MAX);
753 *paddr = (uint16_t)(vAddr & 0xFFFF);
754 break;
755 }
756 case R_X86_64_PC16: {//16-bit sign-extended PC relative.
757 int16_t *paddr = (int16_t*)&(*text)[rel->getOffset()];
758 int64_t vOffset = S + A - P;
759 rsl_assert(vOffset <= INT16_MAX && vOffset >= INT16_MIN);
760 *paddr = (int16_t)(vOffset & 0xFFFF);
761 break;
762 }
763 case R_X86_64_8: {//Direct 8-bit sign-extended.
764 int8_t *paddr = (int8_t*)&(*text)[rel->getOffset()];
765 int64_t vAddr = S + A;
766 rsl_assert(vAddr <= INT8_MAX && vAddr >= INT8_MIN);
767 *paddr = (uint8_t)(vAddr & 0xFF);
768 break;
769 }
770 case R_X86_64_PC8: {//8-bit sign-extended PC relative.
771 int8_t *paddr = (int8_t*)&(*text)[rel->getOffset()];
772 int64_t vOffset = S + A - P;
773 rsl_assert(vOffset <= INT8_MAX && vOffset >= INT8_MIN);
774 *paddr = (int8_t)(vOffset & 0xFF);
775 break;
776 }
777 case R_X86_64_PC64: {//PC relative 64-bit.
778 int64_t *paddr = (int64_t*)&(*text)[rel->getOffset()];
779 *paddr = (int64_t)(S + A - P);
780 break;
781 }
782 }
783 }
784 }
785
786 template <unsigned Bitwidth>
787 inline void ELFObject<Bitwidth>::
relocateX86_32(void * (* find_sym)(void * context,char const * name),void * context,ELFSectionRelTableTy * reltab,ELFSectionProgBitsTy * text)788 relocateX86_32(void *(*find_sym)(void *context, char const *name),
789 void *context,
790 ELFSectionRelTableTy *reltab,
791 ELFSectionProgBitsTy *text) {
792 rsl_assert(Bitwidth == 32 && "Only support X86.");
793
794 ELFSectionSymTabTy *symtab =
795 static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
796 rsl_assert(symtab && "Symtab is required.");
797
798 for (size_t i = 0; i < reltab->size(); ++i) {
799 // FIXME: Can not implement here, use Fixup!
800 ELFRelocTy *rel = (*reltab)[i];
801 ELFSymbolTy *sym = (*symtab)[rel->getSymTabIndex()];
802
803 typedef intptr_t Inst_t;
804 Inst_t *inst = (Inst_t *)&(*text)[rel->getOffset()];
805 Inst_t P = (Inst_t)inst;
806 Inst_t A = (Inst_t)*inst;
807 Inst_t S = (Inst_t)sym->getAddress(EM_386);
808
809 if (S == 0) {
810 S = (Inst_t)find_sym(context, sym->getName());
811 if (!S) {
812 missingSymbols = true;
813 }
814 sym->setAddress((void *)S);
815 }
816
817 switch (rel->getType()) {
818 default:
819 rsl_assert(0 && "Not implemented relocation type.");
820 break;
821
822 case R_386_PC32: {//Add PC-relative symbol value.
823 int32_t *paddr = (int32_t*)&(*text)[rel->getOffset()];
824 *paddr = (int32_t)(S + A - P);
825 break;
826 }
827 case R_386_32: {//Add symbol value.
828 uint32_t *paddr = (uint32_t*)&(*text)[rel->getOffset()];
829 *paddr = (uint32_t)(S + A);
830 break;
831 }
832 }
833 }
834 }
835
836 template <unsigned Bitwidth>
837 inline void ELFObject<Bitwidth>::
relocateMIPS(void * (* find_sym)(void * context,char const * name),void * context,ELFSectionRelTableTy * reltab,ELFSectionProgBitsTy * text)838 relocateMIPS(void *(*find_sym)(void *context, char const *name),
839 void *context,
840 ELFSectionRelTableTy *reltab,
841 ELFSectionProgBitsTy *text) {
842 rsl_assert(Bitwidth == 32 && "Only support 32-bit MIPS.");
843
844 ELFSectionSymTabTy *symtab =
845 static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
846 rsl_assert(symtab && "Symtab is required.");
847
848 for (size_t i = 0; i < reltab->size(); ++i) {
849 // FIXME: Can not implement here, use Fixup!
850 ELFRelocTy *rel = (*reltab)[i];
851 ELFSymbolTy *sym = (*symtab)[rel->getSymTabIndex()];
852
853 typedef int32_t Inst_t;
854 Inst_t *inst = (Inst_t *)&(*text)[rel->getOffset()];
855 Inst_t P = (Inst_t)(uintptr_t)inst;
856 Inst_t A = (Inst_t)(uintptr_t)*inst;
857 Inst_t S = (Inst_t)(uintptr_t)sym->getAddress(EM_MIPS);
858
859 bool need_stub = false;
860
861 if (S == 0 && strcmp (sym->getName(), "_gp_disp") != 0) {
862 need_stub = true;
863 S = (Inst_t)(uintptr_t)find_sym(context, sym->getName());
864 if (!S) {
865 missingSymbols = true;
866 }
867 #if defined(__LP64__) || defined(__x86_64__)
868 llvm::errs() << "Code temporarily disabled for 64bit build";
869 abort();
870 #else
871 sym->setAddress((void *)S);
872 #endif
873 }
874
875 switch (rel->getType()) {
876 default:
877 rsl_assert(0 && "Not implemented relocation type.");
878 break;
879
880 case R_MIPS_NONE:
881 case R_MIPS_JALR: // ignore this
882 break;
883
884 case R_MIPS_16:
885 *inst &= 0xFFFF0000;
886 A = A & 0xFFFF;
887 A = S + (short)A;
888 rsl_assert(A >= -32768 && A <= 32767 && "R_MIPS_16 overflow.");
889 *inst |= (A & 0xFFFF);
890 break;
891
892 case R_MIPS_32:
893 *inst = S + A;
894 break;
895
896 case R_MIPS_26:
897 *inst &= 0xFC000000;
898 if (need_stub == false) {
899 A = (A & 0x3FFFFFF) << 2;
900 if (sym->getBindingAttribute() == STB_LOCAL) { // local binding
901 A |= ((P + 4) & 0xF0000000);
902 A += S;
903 *inst |= ((A >> 2) & 0x3FFFFFF);
904 } else { // external binding
905 if (A & 0x08000000) // Sign extend from bit 27
906 A |= 0xF0000000;
907 A += S;
908 *inst |= ((A >> 2) & 0x3FFFFFF);
909 if (((P + 4) >> 28) != (A >> 28)) { // far local call
910 #if defined(__LP64__) || defined(__x86_64__)
911 llvm::errs() << "Code temporarily disabled for 64bit build";
912 abort();
913 void* stub = NULL;
914 #else
915 void *stub = text->getStubLayout()->allocateStub((void *)A);
916 #endif
917 rsl_assert(stub && "cannot allocate stub.");
918 sym->setAddress(stub);
919 S = (int32_t)(intptr_t)stub;
920 *inst |= ((S >> 2) & 0x3FFFFFF);
921 rsl_assert(((P + 4) >> 28) == (S >> 28) && "stub is too far.");
922 }
923 }
924 } else { // shared-library call
925 A = (A & 0x3FFFFFF) << 2;
926 rsl_assert(A == 0 && "R_MIPS_26 addend is not zero.");
927 #if defined(__LP64__) || defined(__x86_64__)
928 llvm::errs() << "Code temporarily disabled for 64bit build";
929 abort();
930 void* stub = NULL;
931 #else
932 void *stub = text->getStubLayout()->allocateStub((void *)S);
933 #endif
934 rsl_assert(stub && "cannot allocate stub.");
935 sym->setAddress(stub);
936 S = (int32_t)(intptr_t)stub;
937 *inst |= ((S >> 2) & 0x3FFFFFF);
938 rsl_assert(((P + 4) >> 28) == (S >> 28) && "stub is too far.");
939 }
940 break;
941
942 case R_MIPS_HI16:
943 *inst &= 0xFFFF0000;
944 A = (A & 0xFFFF) << 16;
945 // Find the nearest LO16 relocation type after this entry
946 for (size_t j = i + 1; j < reltab->size(); j++) {
947 ELFRelocTy *this_rel = (*reltab)[j];
948 ELFSymbolTy *this_sym = (*symtab)[this_rel->getSymTabIndex()];
949 if (this_rel->getType() == R_MIPS_LO16 && this_sym == sym) {
950 Inst_t *this_inst = (Inst_t *)&(*text)[this_rel->getOffset()];
951 Inst_t this_A = (Inst_t)(uintptr_t)*this_inst;
952 this_A = this_A & 0xFFFF;
953 A += (short)this_A;
954 break;
955 }
956 }
957 if (strcmp (sym->getName(), "_gp_disp") == 0) {
958 S = (int)(intptr_t)got_address() + GP_OFFSET - (int)P;
959 #if defined(__LP64__) || defined(__x86_64__)
960 llvm::errs() << "Code temporarily disabled for 64bit build";
961 abort();
962 #else
963 sym->setAddress((void *)S);
964 #endif
965 }
966 *inst |= (((S + A + (int)0x8000) >> 16) & 0xFFFF);
967 break;
968
969 case R_MIPS_LO16:
970 *inst &= 0xFFFF0000;
971 A = A & 0xFFFF;
972 if (strcmp (sym->getName(), "_gp_disp") == 0) {
973 S = (Inst_t)(intptr_t)sym->getAddress(EM_MIPS);
974 }
975 *inst |= ((S + A) & 0xFFFF);
976 break;
977
978 case R_MIPS_GOT16:
979 case R_MIPS_CALL16:
980 {
981 *inst &= 0xFFFF0000;
982 A = A & 0xFFFF;
983 if (rel->getType() == R_MIPS_GOT16) {
984 if (sym->getBindingAttribute() == STB_LOCAL) {
985 A <<= 16;
986
987 // Find the nearest LO16 relocation type after this entry
988 for (size_t j = i + 1; j < reltab->size(); j++) {
989 ELFRelocTy *this_rel = (*reltab)[j];
990 ELFSymbolTy *this_sym = (*symtab)[this_rel->getSymTabIndex()];
991 if (this_rel->getType() == R_MIPS_LO16 && this_sym == sym) {
992 Inst_t *this_inst = (Inst_t *)&(*text)[this_rel->getOffset()];
993 Inst_t this_A = (Inst_t)(uintptr_t)*this_inst;
994 this_A = this_A & 0xFFFF;
995 A += (short)this_A;
996 break;
997 }
998 }
999 } else {
1000 rsl_assert(A == 0 && "R_MIPS_GOT16 addend is not 0.");
1001 }
1002 } else { // R_MIPS_CALL16
1003 rsl_assert(A == 0 && "R_MIPS_CALL16 addend is not 0.");
1004 }
1005 #if defined(__LP64__) || defined(__x86_64__)
1006 llvm::errs() << "Code temporarily disabled for 64bit build";
1007 abort();
1008 int got_index = 0;
1009 #else
1010 int got_index = search_got((int)rel->getSymTabIndex(), (void *)(S + A),
1011 sym->getBindingAttribute());
1012 #endif
1013 int got_offset = (got_index << 2) - GP_OFFSET;
1014 *inst |= (got_offset & 0xFFFF);
1015 }
1016 break;
1017
1018 case R_MIPS_GPREL32:
1019 *inst = A + S - ((int)(intptr_t)got_address() + GP_OFFSET);
1020 break;
1021 }
1022 }
1023 }
1024
1025
1026 // TODO: Refactor all relocations.
1027 template <unsigned Bitwidth>
1028 inline void ELFObject<Bitwidth>::
relocate(void * (* find_sym)(void * context,char const * name),void * context)1029 relocate(void *(*find_sym)(void *context, char const *name), void *context) {
1030 // Init SHNCommonDataSize.
1031 // Need refactoring
1032 size_t SHNCommonDataSize = 0;
1033
1034 ELFSectionSymTabTy *symtab =
1035 static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
1036 rsl_assert(symtab && "Symtab is required.");
1037
1038 for (size_t i = 0; i < symtab->size(); ++i) {
1039 ELFSymbolTy *sym = (*symtab)[i];
1040
1041 if (sym->getType() != STT_OBJECT) {
1042 continue;
1043 }
1044
1045 size_t idx = (size_t)sym->getSectionIndex();
1046 switch (idx) {
1047 default:
1048 if ((*shtab)[idx]->getType() == SHT_NOBITS) {
1049 // FIXME(logan): This is a workaround for .lcomm directives
1050 // bug of LLVM ARM MC code generator. Remove this when the
1051 // LLVM bug is fixed.
1052
1053 size_t align = 16;
1054 SHNCommonDataSize += (size_t)sym->getSize() + align;
1055 }
1056 break;
1057
1058 case SHN_COMMON:
1059 {
1060 size_t align = (size_t)sym->getValue();
1061 SHNCommonDataSize += (size_t)sym->getSize() + align;
1062 }
1063 break;
1064
1065 case SHN_ABS:
1066 case SHN_UNDEF:
1067 case SHN_XINDEX:
1068 break;
1069 }
1070 }
1071 if (!initSHNCommonDataSize(SHNCommonDataSize)) {
1072 rsl_assert("Allocate memory for common variable fail!");
1073 // TODO: Refactor object loading to use proper status/error returns.
1074 // We mark the object as having missing symbols and return early in this
1075 // case to signal a loading error (usually due to running out of
1076 // available memory to allocate).
1077 missingSymbols = true;
1078 return;
1079 }
1080
1081 for (size_t i = 0; i < stab.size(); ++i) {
1082 ELFSectionHeaderTy *sh = (*shtab)[i];
1083 if (sh->getType() != SHT_REL && sh->getType() != SHT_RELA) {
1084 continue;
1085 }
1086 ELFSectionRelTableTy *reltab =
1087 static_cast<ELFSectionRelTableTy *>(stab[i]);
1088 rsl_assert(reltab && "Relocation section can't be NULL.");
1089
1090 const char *reltab_name = sh->getName();
1091 const char *need_rel_name;
1092 if (sh->getType() == SHT_REL) {
1093 need_rel_name = reltab_name + 4;
1094 // ".rel.xxxx"
1095 // ^ start from here.
1096 } else {
1097 need_rel_name = reltab_name + 5;
1098 }
1099
1100 // TODO: We currently skip relocations of ARM unwind information, because
1101 // it is unused.
1102 if (!strcmp(".ARM.exidx", need_rel_name)) {
1103 continue;
1104 }
1105
1106 ELFSectionProgBitsTy *need_rel =
1107 static_cast<ELFSectionProgBitsTy *>(getSectionByName(need_rel_name));
1108 rsl_assert(need_rel && "Need be relocated section can't be NULL.");
1109
1110 switch (getHeader()->getMachine()) {
1111 case EM_ARM:
1112 relocateARM(find_sym, context, reltab, need_rel);
1113 break;
1114 case EM_AARCH64:
1115 relocateAARCH64(find_sym, context, reltab, need_rel);
1116 break;
1117 case EM_386:
1118 relocateX86_32(find_sym, context, reltab, need_rel);
1119 break;
1120 case EM_X86_64:
1121 relocateX86_64(find_sym, context, reltab, need_rel);
1122 break;
1123 case EM_MIPS:
1124 relocateMIPS(find_sym, context, reltab, need_rel);
1125 break;
1126
1127 default:
1128 rsl_assert(0 && "Only support ARM, MIPS, X86, and X86_64 relocation.");
1129 break;
1130 }
1131 }
1132
1133 for (size_t i = 0; i < stab.size(); ++i) {
1134 ELFSectionHeaderTy *sh = (*shtab)[i];
1135 if (sh->getType() == SHT_PROGBITS || sh->getType() == SHT_NOBITS) {
1136 if (stab[i]) {
1137 static_cast<ELFSectionBitsTy *>(stab[i])->protect();
1138 }
1139 }
1140 }
1141 }
1142
1143 template <unsigned Bitwidth>
print() const1144 inline void ELFObject<Bitwidth>::print() const {
1145 header->print();
1146 shtab->print();
1147
1148 for (size_t i = 0; i < stab.size(); ++i) {
1149 ELFSectionTy *sec = stab[i];
1150 if (sec) {
1151 sec->print();
1152 }
1153 }
1154 }
1155
1156 #endif // ELF_OBJECT_HXX
1157