1 //===- ARMRelocator.cpp ----------------------------------------===//
2 //
3 // The MCLinker Project
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===--------------------------------------------------------------------===//
9
10 #include <mcld/LinkerConfig.h>
11 #include <mcld/IRBuilder.h>
12 #include <llvm/ADT/Twine.h>
13 #include <llvm/Support/DataTypes.h>
14 #include <llvm/Support/ELF.h>
15 #include <llvm/Support/Host.h>
16 #include <mcld/Support/MsgHandling.h>
17 #include <mcld/LD/LDSymbol.h>
18 #include <mcld/Object/ObjectBuilder.h>
19 #include "ARMRelocator.h"
20 #include "ARMRelocationFunctions.h"
21
22 using namespace mcld;
23
24 //===--------------------------------------------------------------------===//
25 // Relocation Functions and Tables
26 //===--------------------------------------------------------------------===//
27 DECL_ARM_APPLY_RELOC_FUNCS
28
29 /// the prototype of applying function
30 typedef Relocator::Result (*ApplyFunctionType)(Relocation& pReloc,
31 ARMRelocator& pParent);
32
33 // the table entry of applying functions
34 struct ApplyFunctionTriple
35 {
36 ApplyFunctionType func;
37 unsigned int type;
38 const char* name;
39 };
40
41 // declare the table of applying functions
42 static const ApplyFunctionTriple ApplyFunctions[] = {
43 DECL_ARM_APPLY_RELOC_FUNC_PTRS
44 };
45
46 //===--------------------------------------------------------------------===//
47 // ARMRelocator
48 //===--------------------------------------------------------------------===//
ARMRelocator(ARMGNULDBackend & pParent,const LinkerConfig & pConfig)49 ARMRelocator::ARMRelocator(ARMGNULDBackend& pParent,
50 const LinkerConfig& pConfig)
51 : Relocator(pConfig),
52 m_Target(pParent) {
53 }
54
~ARMRelocator()55 ARMRelocator::~ARMRelocator()
56 {
57 }
58
59 Relocator::Result
applyRelocation(Relocation & pRelocation)60 ARMRelocator::applyRelocation(Relocation& pRelocation)
61 {
62 Relocation::Type type = pRelocation.type();
63 if (type > 130) { // 131-255 doesn't noted in ARM spec
64 return Relocator::Unknown;
65 }
66
67 return ApplyFunctions[type].func(pRelocation, *this);
68 }
69
getName(Relocator::Type pType) const70 const char* ARMRelocator::getName(Relocator::Type pType) const
71 {
72 return ApplyFunctions[pType].name;
73 }
74
getSize(Relocation::Type pType) const75 Relocator::Size ARMRelocator::getSize(Relocation::Type pType) const
76 {
77 return 32;
78 }
79
addCopyReloc(ResolveInfo & pSym)80 void ARMRelocator::addCopyReloc(ResolveInfo& pSym)
81 {
82 Relocation& rel_entry = *getTarget().getRelDyn().consumeEntry();
83 rel_entry.setType(llvm::ELF::R_ARM_COPY);
84 assert(pSym.outSymbol()->hasFragRef());
85 rel_entry.targetRef().assign(*pSym.outSymbol()->fragRef());
86 rel_entry.setSymInfo(&pSym);
87 }
88
89 /// defineSymbolForCopyReloc
90 /// For a symbol needing copy relocation, define a copy symbol in the BSS
91 /// section and all other reference to this symbol should refer to this
92 /// copy.
93 /// This is executed at scan relocation stage.
94 LDSymbol&
defineSymbolforCopyReloc(IRBuilder & pBuilder,const ResolveInfo & pSym)95 ARMRelocator::defineSymbolforCopyReloc(IRBuilder& pBuilder,
96 const ResolveInfo& pSym)
97 {
98 // get or create corresponding BSS LDSection
99 LDSection* bss_sect_hdr = NULL;
100 ELFFileFormat* file_format = getTarget().getOutputFormat();
101 if (ResolveInfo::ThreadLocal == pSym.type())
102 bss_sect_hdr = &file_format->getTBSS();
103 else
104 bss_sect_hdr = &file_format->getBSS();
105
106 // get or create corresponding BSS SectionData
107 SectionData* bss_data = NULL;
108 if (bss_sect_hdr->hasSectionData())
109 bss_data = bss_sect_hdr->getSectionData();
110 else
111 bss_data = IRBuilder::CreateSectionData(*bss_sect_hdr);
112
113 // Determine the alignment by the symbol value
114 // FIXME: here we use the largest alignment
115 uint32_t addralign = config().targets().bitclass() / 8;
116
117 // allocate space in BSS for the copy symbol
118 Fragment* frag = new FillFragment(0x0, 1, pSym.size());
119 uint64_t size = ObjectBuilder::AppendFragment(*frag,
120 *bss_data,
121 addralign);
122 bss_sect_hdr->setSize(bss_sect_hdr->size() + size);
123
124 // change symbol binding to Global if it's a weak symbol
125 ResolveInfo::Binding binding = (ResolveInfo::Binding)pSym.binding();
126 if (binding == ResolveInfo::Weak)
127 binding = ResolveInfo::Global;
128
129 // Define the copy symbol in the bss section and resolve it
130 LDSymbol* cpy_sym = pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Resolve>(
131 pSym.name(),
132 (ResolveInfo::Type)pSym.type(),
133 ResolveInfo::Define,
134 binding,
135 pSym.size(), // size
136 0x0, // value
137 FragmentRef::Create(*frag, 0x0),
138 (ResolveInfo::Visibility)pSym.other());
139
140 return *cpy_sym;
141 }
142
143 /// checkValidReloc - When we attempt to generate a dynamic relocation for
144 /// ouput file, check if the relocation is supported by dynamic linker.
checkValidReloc(Relocation & pReloc) const145 void ARMRelocator::checkValidReloc(Relocation& pReloc) const
146 {
147 // If not PIC object, no relocation type is invalid
148 if (!config().isCodeIndep())
149 return;
150
151 switch(pReloc.type()) {
152 case llvm::ELF::R_ARM_RELATIVE:
153 case llvm::ELF::R_ARM_COPY:
154 case llvm::ELF::R_ARM_GLOB_DAT:
155 case llvm::ELF::R_ARM_JUMP_SLOT:
156 case llvm::ELF::R_ARM_ABS32:
157 case llvm::ELF::R_ARM_ABS32_NOI:
158 case llvm::ELF::R_ARM_PC24:
159 case llvm::ELF::R_ARM_TLS_DTPMOD32:
160 case llvm::ELF::R_ARM_TLS_DTPOFF32:
161 case llvm::ELF::R_ARM_TLS_TPOFF32:
162 break;
163
164 default:
165 error(diag::non_pic_relocation) << (int)pReloc.type()
166 << pReloc.symInfo()->name();
167 break;
168 }
169 }
170
171 void
scanLocalReloc(Relocation & pReloc,const LDSection & pSection)172 ARMRelocator::scanLocalReloc(Relocation& pReloc, const LDSection& pSection)
173 {
174 // rsym - The relocation target symbol
175 ResolveInfo* rsym = pReloc.symInfo();
176
177 switch(pReloc.type()){
178
179 // Set R_ARM_TARGET1 to R_ARM_ABS32
180 // Ref: GNU gold 1.11 arm.cc, line 9892
181 // FIXME: R_ARM_TARGET1 should be set by option --target1-rel
182 // or --target1-rel
183 case llvm::ELF::R_ARM_TARGET1:
184 pReloc.setType(llvm::ELF::R_ARM_ABS32);
185 case llvm::ELF::R_ARM_ABS32:
186 case llvm::ELF::R_ARM_ABS32_NOI: {
187 // If buiding PIC object (shared library or PIC executable),
188 // a dynamic relocations with RELATIVE type to this location is needed.
189 // Reserve an entry in .rel.dyn
190 if (config().isCodeIndep()) {
191 getTarget().getRelDyn().reserveEntry();
192 // set Rel bit
193 rsym->setReserved(rsym->reserved() | ReserveRel);
194 getTarget().checkAndSetHasTextRel(*pSection.getLink());
195 }
196 return;
197 }
198
199 case llvm::ELF::R_ARM_ABS16:
200 case llvm::ELF::R_ARM_ABS12:
201 case llvm::ELF::R_ARM_THM_ABS5:
202 case llvm::ELF::R_ARM_ABS8:
203 case llvm::ELF::R_ARM_BASE_ABS:
204 case llvm::ELF::R_ARM_MOVW_ABS_NC:
205 case llvm::ELF::R_ARM_MOVT_ABS:
206 case llvm::ELF::R_ARM_THM_MOVW_ABS_NC:
207 case llvm::ELF::R_ARM_THM_MOVT_ABS: {
208 // PIC code should not contain these kinds of relocation
209 if (config().isCodeIndep()) {
210 error(diag::non_pic_relocation) << (int)pReloc.type()
211 << pReloc.symInfo()->name();
212 }
213 return;
214 }
215 case llvm::ELF::R_ARM_GOTOFF32:
216 case llvm::ELF::R_ARM_GOTOFF12: {
217 // FIXME: A GOT section is needed
218 return;
219 }
220
221 // Set R_ARM_TARGET2 to R_ARM_GOT_PREL
222 // Ref: GNU gold 1.11 arm.cc, line 9892
223 // FIXME: R_ARM_TARGET2 should be set by option --target2
224 case llvm::ELF::R_ARM_TARGET2:
225 pReloc.setType(llvm::ELF::R_ARM_GOT_PREL);
226 case llvm::ELF::R_ARM_GOT_BREL:
227 case llvm::ELF::R_ARM_GOT_PREL: {
228 // A GOT entry is needed for these relocation type.
229 // return if we already create GOT for this symbol
230 if (rsym->reserved() & (ReserveGOT | GOTRel))
231 return;
232 getTarget().getGOT().reserveGOT();
233 // If building PIC object, a dynamic relocation with
234 // type RELATIVE is needed to relocate this GOT entry.
235 // Reserve an entry in .rel.dyn
236 if (config().isCodeIndep()) {
237 // create .rel.dyn section if not exist
238 getTarget().getRelDyn().reserveEntry();
239 // set GOTRel bit
240 rsym->setReserved(rsym->reserved() | 0x4u);
241 return;
242 }
243 // set GOT bit
244 rsym->setReserved(rsym->reserved() | 0x2u);
245 return;
246 }
247
248 case llvm::ELF::R_ARM_BASE_PREL: {
249 // FIXME: Currently we only support R_ARM_BASE_PREL against
250 // symbol _GLOBAL_OFFSET_TABLE_
251 if (rsym != getTarget().getGOTSymbol()->resolveInfo())
252 fatal(diag::base_relocation) << (int)pReloc.type() << rsym->name()
253 << "mclinker@googlegroups.com";
254 return;
255 }
256 case llvm::ELF::R_ARM_COPY:
257 case llvm::ELF::R_ARM_GLOB_DAT:
258 case llvm::ELF::R_ARM_JUMP_SLOT:
259 case llvm::ELF::R_ARM_RELATIVE: {
260 // These are relocation type for dynamic linker, shold not
261 // appear in object file.
262 fatal(diag::dynamic_relocation) << (int)pReloc.type();
263 break;
264 }
265 default: {
266 break;
267 }
268 } // end switch
269 }
270
scanGlobalReloc(Relocation & pReloc,IRBuilder & pBuilder,const LDSection & pSection)271 void ARMRelocator::scanGlobalReloc(Relocation& pReloc,
272 IRBuilder& pBuilder,
273 const LDSection& pSection)
274 {
275 // rsym - The relocation target symbol
276 ResolveInfo* rsym = pReloc.symInfo();
277
278 switch(pReloc.type()) {
279
280 // Set R_ARM_TARGET1 to R_ARM_ABS32
281 // Ref: GNU gold 1.11 arm.cc, line 9892
282 // FIXME: R_ARM_TARGET1 should be set by option --target1-rel
283 // or --target1-rel
284 case llvm::ELF::R_ARM_TARGET1:
285 pReloc.setType(llvm::ELF::R_ARM_ABS32);
286 case llvm::ELF::R_ARM_ABS32:
287 case llvm::ELF::R_ARM_ABS16:
288 case llvm::ELF::R_ARM_ABS12:
289 case llvm::ELF::R_ARM_THM_ABS5:
290 case llvm::ELF::R_ARM_ABS8:
291 case llvm::ELF::R_ARM_BASE_ABS:
292 case llvm::ELF::R_ARM_MOVW_ABS_NC:
293 case llvm::ELF::R_ARM_MOVT_ABS:
294 case llvm::ELF::R_ARM_THM_MOVW_ABS_NC:
295 case llvm::ELF::R_ARM_THM_MOVT_ABS:
296 case llvm::ELF::R_ARM_ABS32_NOI: {
297 // Absolute relocation type, symbol may needs PLT entry or
298 // dynamic relocation entry
299 if (getTarget().symbolNeedsPLT(*rsym)) {
300 // create plt for this symbol if it does not have one
301 if (!(rsym->reserved() & ReservePLT)){
302 // Symbol needs PLT entry, we need to reserve a PLT entry
303 // and the corresponding GOT and dynamic relocation entry
304 // in .got and .rel.plt. (GOT entry will be reserved simultaneously
305 // when calling ARMPLT->reserveEntry())
306 getTarget().getPLT().reserveEntry();
307 getTarget().getRelPLT().reserveEntry();
308 // set PLT bit
309 rsym->setReserved(rsym->reserved() | ReservePLT);
310 }
311 }
312
313 if (getTarget().symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT), true)) {
314 // symbol needs dynamic relocation entry, reserve an entry in .rel.dyn
315 getTarget().getRelDyn().reserveEntry();
316 if (getTarget().symbolNeedsCopyReloc(pReloc, *rsym)) {
317 LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym);
318 addCopyReloc(*cpy_sym.resolveInfo());
319 }
320 else {
321 checkValidReloc(pReloc);
322 // set Rel bit
323 rsym->setReserved(rsym->reserved() | ReserveRel);
324 getTarget().checkAndSetHasTextRel(*pSection.getLink());
325 }
326 }
327 return;
328 }
329
330 case llvm::ELF::R_ARM_GOTOFF32:
331 case llvm::ELF::R_ARM_GOTOFF12: {
332 // FIXME: A GOT section is needed
333 return;
334 }
335
336 case llvm::ELF::R_ARM_BASE_PREL:
337 case llvm::ELF::R_ARM_THM_MOVW_BREL_NC:
338 case llvm::ELF::R_ARM_THM_MOVW_BREL:
339 case llvm::ELF::R_ARM_THM_MOVT_BREL:
340 // FIXME: Currently we only support these relocations against
341 // symbol _GLOBAL_OFFSET_TABLE_
342 if (rsym != getTarget().getGOTSymbol()->resolveInfo()) {
343 fatal(diag::base_relocation) << (int)pReloc.type() << rsym->name()
344 << "mclinker@googlegroups.com";
345 }
346 case llvm::ELF::R_ARM_REL32:
347 case llvm::ELF::R_ARM_LDR_PC_G0:
348 case llvm::ELF::R_ARM_SBREL32:
349 case llvm::ELF::R_ARM_THM_PC8:
350 case llvm::ELF::R_ARM_MOVW_PREL_NC:
351 case llvm::ELF::R_ARM_MOVT_PREL:
352 case llvm::ELF::R_ARM_THM_MOVW_PREL_NC:
353 case llvm::ELF::R_ARM_THM_MOVT_PREL:
354 case llvm::ELF::R_ARM_THM_ALU_PREL_11_0:
355 case llvm::ELF::R_ARM_THM_PC12:
356 case llvm::ELF::R_ARM_REL32_NOI:
357 case llvm::ELF::R_ARM_ALU_PC_G0_NC:
358 case llvm::ELF::R_ARM_ALU_PC_G0:
359 case llvm::ELF::R_ARM_ALU_PC_G1_NC:
360 case llvm::ELF::R_ARM_ALU_PC_G1:
361 case llvm::ELF::R_ARM_ALU_PC_G2:
362 case llvm::ELF::R_ARM_LDR_PC_G1:
363 case llvm::ELF::R_ARM_LDR_PC_G2:
364 case llvm::ELF::R_ARM_LDRS_PC_G0:
365 case llvm::ELF::R_ARM_LDRS_PC_G1:
366 case llvm::ELF::R_ARM_LDRS_PC_G2:
367 case llvm::ELF::R_ARM_LDC_PC_G0:
368 case llvm::ELF::R_ARM_LDC_PC_G1:
369 case llvm::ELF::R_ARM_LDC_PC_G2:
370 case llvm::ELF::R_ARM_ALU_SB_G0_NC:
371 case llvm::ELF::R_ARM_ALU_SB_G0:
372 case llvm::ELF::R_ARM_ALU_SB_G1_NC:
373 case llvm::ELF::R_ARM_ALU_SB_G1:
374 case llvm::ELF::R_ARM_ALU_SB_G2:
375 case llvm::ELF::R_ARM_LDR_SB_G0:
376 case llvm::ELF::R_ARM_LDR_SB_G1:
377 case llvm::ELF::R_ARM_LDR_SB_G2:
378 case llvm::ELF::R_ARM_LDRS_SB_G0:
379 case llvm::ELF::R_ARM_LDRS_SB_G1:
380 case llvm::ELF::R_ARM_LDRS_SB_G2:
381 case llvm::ELF::R_ARM_LDC_SB_G0:
382 case llvm::ELF::R_ARM_LDC_SB_G1:
383 case llvm::ELF::R_ARM_LDC_SB_G2:
384 case llvm::ELF::R_ARM_MOVW_BREL_NC:
385 case llvm::ELF::R_ARM_MOVT_BREL:
386 case llvm::ELF::R_ARM_MOVW_BREL: {
387 // Relative addressing relocation, may needs dynamic relocation
388 if (getTarget().symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT), false)) {
389 // symbol needs dynamic relocation entry, reserve an entry in .rel.dyn
390 getTarget().getRelDyn().reserveEntry();
391 if (getTarget().symbolNeedsCopyReloc(pReloc, *rsym)) {
392 LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym);
393 addCopyReloc(*cpy_sym.resolveInfo());
394 }
395 else {
396 checkValidReloc(pReloc);
397 // set Rel bit
398 rsym->setReserved(rsym->reserved() | ReserveRel);
399 getTarget().checkAndSetHasTextRel(*pSection.getLink());
400 }
401 }
402 return;
403 }
404
405 case llvm::ELF::R_ARM_PC24:
406 case llvm::ELF::R_ARM_THM_CALL:
407 case llvm::ELF::R_ARM_PLT32:
408 case llvm::ELF::R_ARM_CALL:
409 case llvm::ELF::R_ARM_JUMP24:
410 case llvm::ELF::R_ARM_THM_JUMP24:
411 case llvm::ELF::R_ARM_SBREL31:
412 case llvm::ELF::R_ARM_PREL31:
413 case llvm::ELF::R_ARM_THM_JUMP19:
414 case llvm::ELF::R_ARM_THM_JUMP6:
415 case llvm::ELF::R_ARM_THM_JUMP11:
416 case llvm::ELF::R_ARM_THM_JUMP8: {
417 // These are branch relocation (except PREL31)
418 // A PLT entry is needed when building shared library
419
420 // return if we already create plt for this symbol
421 if (rsym->reserved() & ReservePLT)
422 return;
423
424 // if the symbol's value can be decided at link time, then no need plt
425 if (getTarget().symbolFinalValueIsKnown(*rsym))
426 return;
427
428 // if symbol is defined in the ouput file and it's not
429 // preemptible, no need plt
430 if (rsym->isDefine() && !rsym->isDyn() &&
431 !getTarget().isSymbolPreemptible(*rsym)) {
432 return;
433 }
434
435 // Symbol needs PLT entry, we need to reserve a PLT entry
436 // and the corresponding GOT and dynamic relocation entry
437 // in .got and .rel.plt. (GOT entry will be reserved simultaneously
438 // when calling ARMPLT->reserveEntry())
439 getTarget().getPLT().reserveEntry();
440 getTarget().getRelPLT().reserveEntry();
441 // set PLT bit
442 rsym->setReserved(rsym->reserved() | ReservePLT);
443 return;
444 }
445
446 // Set R_ARM_TARGET2 to R_ARM_GOT_PREL
447 // Ref: GNU gold 1.11 arm.cc, line 9892
448 // FIXME: R_ARM_TARGET2 should be set by option --target2
449 case llvm::ELF::R_ARM_TARGET2:
450 pReloc.setType(llvm::ELF::R_ARM_GOT_PREL);
451 case llvm::ELF::R_ARM_GOT_BREL:
452 case llvm::ELF::R_ARM_GOT_ABS:
453 case llvm::ELF::R_ARM_GOT_PREL: {
454 // Symbol needs GOT entry, reserve entry in .got
455 // return if we already create GOT for this symbol
456 if (rsym->reserved() & (ReserveGOT | GOTRel))
457 return;
458 getTarget().getGOT().reserveGOT();
459 // if the symbol cannot be fully resolved at link time, then we need a
460 // dynamic relocation
461 if (!getTarget().symbolFinalValueIsKnown(*rsym)) {
462 getTarget().getRelDyn().reserveEntry();
463 // set GOTRel bit
464 rsym->setReserved(rsym->reserved() | GOTRel);
465 return;
466 }
467 // set GOT bit
468 rsym->setReserved(rsym->reserved() | ReserveGOT);
469 return;
470 }
471
472 case llvm::ELF::R_ARM_COPY:
473 case llvm::ELF::R_ARM_GLOB_DAT:
474 case llvm::ELF::R_ARM_JUMP_SLOT:
475 case llvm::ELF::R_ARM_RELATIVE: {
476 // These are relocation type for dynamic linker, shold not
477 // appear in object file.
478 fatal(diag::dynamic_relocation) << (int)pReloc.type();
479 break;
480 }
481 default: {
482 break;
483 }
484 } // end switch
485 }
486
scanRelocation(Relocation & pReloc,IRBuilder & pBuilder,Module & pModule,LDSection & pSection)487 void ARMRelocator::scanRelocation(Relocation& pReloc,
488 IRBuilder& pBuilder,
489 Module& pModule,
490 LDSection& pSection)
491 {
492 // rsym - The relocation target symbol
493 ResolveInfo* rsym = pReloc.symInfo();
494 assert(NULL != rsym &&
495 "ResolveInfo of relocation not set while scanRelocation");
496
497 pReloc.updateAddend();
498 assert(NULL != pSection.getLink());
499 if (0 == (pSection.getLink()->flag() & llvm::ELF::SHF_ALLOC))
500 return;
501
502 // Scan relocation type to determine if an GOT/PLT/Dynamic Relocation
503 // entries should be created.
504 // FIXME: Below judgements concern nothing about TLS related relocation
505
506 // rsym is local
507 if (rsym->isLocal())
508 scanLocalReloc(pReloc, pSection);
509
510 // rsym is external
511 else
512 scanGlobalReloc(pReloc, pBuilder, pSection);
513
514 // check if we shoule issue undefined reference for the relocation target
515 // symbol
516 if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak() && !rsym->isNull())
517 fatal(diag::undefined_reference) << rsym->name();
518 }
519
520 //===--------------------------------------------------------------------===//
521 // non-member functions
522 //===--------------------------------------------------------------------===//
getThumbBit(const Relocation & pReloc)523 static Relocator::DWord getThumbBit(const Relocation& pReloc)
524 {
525 // Set thumb bit if
526 // - symbol has type of STT_FUNC, is defined and with bit 0 of its value set
527 Relocator::DWord thumbBit =
528 ((!pReloc.symInfo()->isUndef() || pReloc.symInfo()->isDyn()) &&
529 (pReloc.symInfo()->type() == ResolveInfo::Function) &&
530 ((pReloc.symValue() & 0x1) != 0))?
531 1:0;
532 return thumbBit;
533 }
534
535 //=========================================//
536 // Relocation helper function //
537 //=========================================//
538
539 // Using uint64_t to make sure those complicate operations won't cause
540 // undefined behavior.
541 static
helper_sign_extend(uint64_t pVal,uint64_t pOri_width)542 uint64_t helper_sign_extend(uint64_t pVal, uint64_t pOri_width)
543 {
544 assert(pOri_width <= 64);
545 if (pOri_width == 64)
546 return pVal;
547 uint64_t mask = (~((uint64_t)0)) >> (64 - pOri_width);
548 pVal &= mask;
549 // Reverse sign bit, then subtract sign bit.
550 uint64_t sign_bit = 1 << (pOri_width - 1);
551 return (pVal ^ sign_bit) - sign_bit;
552 }
553
554 static
helper_bit_select(uint64_t pA,uint64_t pB,uint64_t pMask)555 uint64_t helper_bit_select(uint64_t pA, uint64_t pB, uint64_t pMask)
556 {
557 return (pA & ~pMask) | (pB & pMask) ;
558 }
559
560 // Check if symbol can use relocation R_ARM_RELATIVE
561 static bool
helper_use_relative_reloc(const ResolveInfo & pSym,const ARMRelocator & pFactory)562 helper_use_relative_reloc(const ResolveInfo& pSym,
563 const ARMRelocator& pFactory)
564 {
565 // if symbol is dynamic or undefine or preemptible
566 if (pSym.isDyn() ||
567 pSym.isUndef() ||
568 pFactory.getTarget().isSymbolPreemptible(pSym))
569 return false;
570 return true;
571 }
572
573 // Strip LSB (THUMB bit) if "S" is a THUMB target.
helper_clear_thumb_bit(ARMRelocator::DWord & pValue)574 static inline void helper_clear_thumb_bit(ARMRelocator::DWord& pValue)
575 {
576 pValue &= (~0x1);
577 }
578
579 static
helper_get_GOT_and_init(Relocation & pReloc,ARMRelocator & pParent)580 ARMGOTEntry& helper_get_GOT_and_init(Relocation& pReloc,
581 ARMRelocator& pParent)
582 {
583 // rsym - The relocation target symbol
584 ResolveInfo* rsym = pReloc.symInfo();
585 ARMGNULDBackend& ld_backend = pParent.getTarget();
586
587 ARMGOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
588 if (NULL == got_entry) {
589 got_entry = ld_backend.getGOT().consumeGOT();
590 pParent.getSymGOTMap().record(*rsym, *got_entry);
591 // If we first get this GOT entry, we should initialize it.
592 if (rsym->reserved() & ARMRelocator::ReserveGOT) {
593 // No corresponding dynamic relocation, initialize to the symbol value.
594 got_entry->setValue(pReloc.symValue());
595 }
596 else if (rsym->reserved() & ARMRelocator::GOTRel) {
597
598 // Initialize corresponding dynamic relocation.
599 Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
600 if ( rsym->isLocal() ||
601 helper_use_relative_reloc(*rsym, pParent)) {
602 // Initialize got entry to target symbol address
603 got_entry->setValue(pReloc.symValue());
604 rel_entry.setType(llvm::ELF::R_ARM_RELATIVE);
605 rel_entry.setSymInfo(0);
606 }
607 else {
608 // Initialize got entry to 0 for corresponding dynamic relocation.
609 got_entry->setValue(0);
610 rel_entry.setType(llvm::ELF::R_ARM_GLOB_DAT);
611 rel_entry.setSymInfo(rsym);
612 }
613 rel_entry.targetRef().assign(*got_entry);
614 }
615 else {
616 fatal(diag::reserve_entry_number_mismatch_got);
617 }
618 }
619 return *got_entry;
620 }
621
622 static
helper_GOT_ORG(ARMRelocator & pParent)623 ARMRelocator::Address helper_GOT_ORG(ARMRelocator& pParent)
624 {
625 return pParent.getTarget().getGOT().addr();
626 }
627
628
629 static
helper_GOT(Relocation & pReloc,ARMRelocator & pParent)630 ARMRelocator::Address helper_GOT(Relocation& pReloc, ARMRelocator& pParent)
631 {
632 ARMGOTEntry& got_entry = helper_get_GOT_and_init(pReloc, pParent);
633 return helper_GOT_ORG(pParent) + got_entry.getOffset();
634 }
635
636
637 static
helper_get_PLT_and_init(Relocation & pReloc,ARMRelocator & pParent)638 ARMPLT1& helper_get_PLT_and_init(Relocation& pReloc, ARMRelocator& pParent)
639 {
640 // rsym - The relocation target symbol
641 ResolveInfo* rsym = pReloc.symInfo();
642 ARMGNULDBackend& ld_backend = pParent.getTarget();
643
644 ARMPLT1* plt_entry = pParent.getSymPLTMap().lookUp(*rsym);
645 if (NULL != plt_entry)
646 return *plt_entry;
647
648 plt_entry = ld_backend.getPLT().consume();
649 pParent.getSymPLTMap().record(*rsym, *plt_entry);
650
651 // If we first get this PLT entry, we should initialize it.
652 if (rsym->reserved() & ARMRelocator::ReservePLT) {
653 ARMGOTEntry* gotplt_entry = pParent.getSymGOTPLTMap().lookUp(*rsym);
654 assert(NULL == gotplt_entry && "PLT entry not exist, but DynRel entry exist!");
655 gotplt_entry = ld_backend.getGOT().consumeGOTPLT();
656 pParent.getSymGOTPLTMap().record(*rsym, *gotplt_entry);
657
658 // Initialize corresponding dynamic relocation.
659 Relocation& rel_entry = *ld_backend.getRelPLT().consumeEntry();
660 rel_entry.setType(llvm::ELF::R_ARM_JUMP_SLOT);
661 rel_entry.targetRef().assign(*gotplt_entry);
662 rel_entry.setSymInfo(rsym);
663 }
664 else {
665 fatal(diag::reserve_entry_number_mismatch_plt);
666 }
667
668 return *plt_entry;
669 }
670
671 static
helper_PLT_ORG(ARMRelocator & pParent)672 ARMRelocator::Address helper_PLT_ORG(ARMRelocator& pParent)
673 {
674 return pParent.getTarget().getPLT().addr();
675 }
676
677
678 static
helper_PLT(Relocation & pReloc,ARMRelocator & pParent)679 ARMRelocator::Address helper_PLT(Relocation& pReloc, ARMRelocator& pParent)
680 {
681 ARMPLT1& plt_entry = helper_get_PLT_and_init(pReloc, pParent);
682 return helper_PLT_ORG(pParent) + plt_entry.getOffset();
683 }
684
685 // Get an relocation entry in .rel.dyn and set its type to pType,
686 // its FragmentRef to pReloc->targetFrag() and its ResolveInfo to
687 // pReloc->symInfo()
688 static
helper_DynRel(Relocation & pReloc,ARMRelocator::Type pType,ARMRelocator & pParent)689 void helper_DynRel(Relocation& pReloc,
690 ARMRelocator::Type pType,
691 ARMRelocator& pParent)
692 {
693 // rsym - The relocation target symbol
694 ResolveInfo* rsym = pReloc.symInfo();
695 ARMGNULDBackend& ld_backend = pParent.getTarget();
696
697 Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
698 rel_entry.setType(pType);
699 rel_entry.targetRef() = pReloc.targetRef();
700
701 if (pType == llvm::ELF::R_ARM_RELATIVE)
702 rel_entry.setSymInfo(0);
703 else
704 rel_entry.setSymInfo(rsym);
705 }
706
707 static ARMRelocator::DWord
helper_extract_movw_movt_addend(ARMRelocator::DWord pTarget)708 helper_extract_movw_movt_addend(ARMRelocator::DWord pTarget)
709 {
710 // imm16: [19-16][11-0]
711 return helper_sign_extend((((pTarget >> 4)) & 0xf000U) | (pTarget & 0xfffU),
712 16);
713 }
714
715 static ARMRelocator::DWord
helper_insert_val_movw_movt_inst(ARMRelocator::DWord pTarget,ARMRelocator::DWord pImm)716 helper_insert_val_movw_movt_inst(ARMRelocator::DWord pTarget,
717 ARMRelocator::DWord pImm)
718 {
719 // imm16: [19-16][11-0]
720 pTarget &= 0xfff0f000U;
721 pTarget |= pImm & 0x0fffU;
722 pTarget |= (pImm & 0xf000U) << 4;
723 return pTarget;
724 }
725
726 static ARMRelocator::DWord
helper_extract_thumb_movw_movt_addend(ARMRelocator::DWord pValue)727 helper_extract_thumb_movw_movt_addend(ARMRelocator::DWord pValue)
728 {
729 // imm16: [19-16][26][14-12][7-0]
730 return helper_sign_extend((((pValue >> 4) & 0xf000U) |
731 ((pValue >> 15) & 0x0800U) |
732 ((pValue >> 4) & 0x0700U) |
733 (pValue& 0x00ffU)),
734 16);
735 }
736
737 static ARMRelocator::DWord
helper_insert_val_thumb_movw_movt_inst(ARMRelocator::DWord pValue,ARMRelocator::DWord pImm)738 helper_insert_val_thumb_movw_movt_inst(ARMRelocator::DWord pValue,
739 ARMRelocator::DWord pImm)
740 {
741 // imm16: [19-16][26][14-12][7-0]
742 pValue &= 0xfbf08f00U;
743 pValue |= (pImm & 0xf000U) << 4;
744 pValue |= (pImm & 0x0800U) << 15;
745 pValue |= (pImm & 0x0700U) << 4;
746 pValue |= (pImm & 0x00ffU);
747 return pValue;
748 }
749
750 static ARMRelocator::DWord
helper_thumb32_branch_offset(ARMRelocator::DWord pUpper16,ARMRelocator::DWord pLower16)751 helper_thumb32_branch_offset(ARMRelocator::DWord pUpper16,
752 ARMRelocator::DWord pLower16)
753 {
754 ARMRelocator::DWord s = (pUpper16 & (1U << 10)) >> 10, // 26 bit
755 u = pUpper16 & 0x3ffU, // 25-16
756 l = pLower16 & 0x7ffU, // 10-0
757 j1 = (pLower16 & (1U << 13)) >> 13, // 13
758 j2 = (pLower16 & (1U << 11)) >> 11; // 11
759 ARMRelocator::DWord i1 = j1 ^ s? 0: 1,
760 i2 = j2 ^ s? 0: 1;
761
762 // [31-25][24][23][22][21-12][11-1][0]
763 // 0 s i1 i2 u l 0
764 return helper_sign_extend((s << 24) | (i1 << 23) | (i2 << 22) |
765 (u << 12) | (l << 1),
766 25);
767 }
768
769 static ARMRelocator::DWord
helper_thumb32_branch_upper(ARMRelocator::DWord pUpper16,ARMRelocator::DWord pOffset)770 helper_thumb32_branch_upper(ARMRelocator::DWord pUpper16,
771 ARMRelocator::DWord pOffset)
772 {
773 uint32_t sign = ((pOffset & 0x80000000U) >> 31);
774 return (pUpper16 & ~0x7ffU) | ((pOffset >> 12) & 0x3ffU) | (sign << 10);
775 }
776
777 static ARMRelocator::DWord
helper_thumb32_branch_lower(ARMRelocator::DWord pLower16,ARMRelocator::DWord pOffset)778 helper_thumb32_branch_lower(ARMRelocator::DWord pLower16,
779 ARMRelocator::DWord pOffset)
780 {
781 uint32_t sign = ((pOffset & 0x80000000U) >> 31);
782 return ((pLower16 & ~0x2fffU) |
783 ((((pOffset >> 23) & 1) ^ !sign) << 13) |
784 ((((pOffset >> 22) & 1) ^ !sign) << 11) |
785 ((pOffset >> 1) & 0x7ffU));
786 }
787
788 // Return true if overflow
789 static bool
helper_check_signed_overflow(ARMRelocator::DWord pValue,unsigned bits)790 helper_check_signed_overflow(ARMRelocator::DWord pValue,
791 unsigned bits)
792 {
793 int32_t signed_val = static_cast<int32_t>(pValue);
794 int32_t max = (1 << (bits - 1)) - 1;
795 int32_t min = -(1 << (bits - 1));
796 if (signed_val > max || signed_val < min) {
797 return true;
798 } else {
799 return false;
800 }
801 }
802
803
804 //=========================================//
805 // Each relocation function implementation //
806 //=========================================//
807
808 // R_ARM_NONE
none(Relocation & pReloc,ARMRelocator & pParent)809 ARMRelocator::Result none(Relocation& pReloc, ARMRelocator& pParent)
810 {
811 return ARMRelocator::OK;
812 }
813
814 // R_ARM_ABS32: (S + A) | T
abs32(Relocation & pReloc,ARMRelocator & pParent)815 ARMRelocator::Result abs32(Relocation& pReloc, ARMRelocator& pParent)
816 {
817 ResolveInfo* rsym = pReloc.symInfo();
818 ARMRelocator::DWord T = getThumbBit(pReloc);
819 ARMRelocator::DWord A = pReloc.target() + pReloc.addend();
820 ARMRelocator::DWord S = pReloc.symValue();
821 if (T != 0x0)
822 helper_clear_thumb_bit(S);
823
824 LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
825
826 // If the flag of target section is not ALLOC, we will not scan this relocation
827 // but perform static relocation. (e.g., applying .debug section)
828 if (0x0 == (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
829 pReloc.target() = (S + A) | T;
830 return ARMRelocator::OK;
831 }
832
833 // A local symbol may need REL Type dynamic relocation
834 if (rsym->isLocal() && (rsym->reserved() & ARMRelocator::ReserveRel)) {
835 helper_DynRel(pReloc, llvm::ELF::R_ARM_RELATIVE, pParent);
836 pReloc.target() = (S + A) | T ;
837 return ARMRelocator::OK;
838 }
839
840 // An external symbol may need PLT and dynamic relocation
841 if (!rsym->isLocal()) {
842 if (rsym->reserved() & ARMRelocator::ReservePLT) {
843 S = helper_PLT(pReloc, pParent);
844 T = 0 ; // PLT is not thumb
845 }
846 // If we generate a dynamic relocation (except R_ARM_RELATIVE)
847 // for a place, we should not perform static relocation on it
848 // in order to keep the addend store in the place correct.
849 if (rsym->reserved() & ARMRelocator::ReserveRel) {
850 if (helper_use_relative_reloc(*rsym, pParent)) {
851 helper_DynRel(pReloc, llvm::ELF::R_ARM_RELATIVE, pParent);
852 }
853 else {
854 helper_DynRel(pReloc, pReloc.type(), pParent);
855 return ARMRelocator::OK;
856 }
857 }
858 }
859
860
861 // perform static relocation
862 pReloc.target() = (S + A) | T;
863 return ARMRelocator::OK;
864 }
865
866 // R_ARM_REL32: ((S + A) | T) - P
rel32(Relocation & pReloc,ARMRelocator & pParent)867 ARMRelocator::Result rel32(Relocation& pReloc, ARMRelocator& pParent)
868 {
869 // perform static relocation
870 ARMRelocator::Address S = pReloc.symValue();
871 ARMRelocator::DWord T = getThumbBit(pReloc);
872 ARMRelocator::DWord A = pReloc.target() + pReloc.addend();
873 if (T != 0x0)
874 helper_clear_thumb_bit(S);
875
876 // An external symbol may need PLT (this reloc is from stub)
877 if (!pReloc.symInfo()->isLocal()) {
878 if (pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT) {
879 S = helper_PLT(pReloc, pParent);
880 T = 0; // PLT is not thumb.
881 }
882 }
883
884 // perform relocation
885 pReloc.target() = ((S + A) | T) - pReloc.place();
886
887 return ARMRelocator::OK;
888 }
889
890 // R_ARM_BASE_PREL: B(S) + A - P
base_prel(Relocation & pReloc,ARMRelocator & pParent)891 ARMRelocator::Result base_prel(Relocation& pReloc, ARMRelocator& pParent)
892 {
893 // perform static relocation
894 ARMRelocator::DWord A = pReloc.target() + pReloc.addend();
895 pReloc.target() = pReloc.symValue() + A - pReloc.place();
896 return ARMRelocator::OK;
897 }
898
899 // R_ARM_GOTOFF32: ((S + A) | T) - GOT_ORG
gotoff32(Relocation & pReloc,ARMRelocator & pParent)900 ARMRelocator::Result gotoff32(Relocation& pReloc, ARMRelocator& pParent)
901 {
902 ARMRelocator::DWord T = getThumbBit(pReloc);
903 ARMRelocator::DWord A = pReloc.target() + pReloc.addend();
904 ARMRelocator::Address GOT_ORG = helper_GOT_ORG(pParent);
905 ARMRelocator::Address S = pReloc.symValue();
906 if (T != 0x0)
907 helper_clear_thumb_bit(S);
908
909 pReloc.target() = ((S + A) | T) - GOT_ORG;
910 return ARMRelocator::OK;
911 }
912
913 // R_ARM_GOT_BREL: GOT(S) + A - GOT_ORG
got_brel(Relocation & pReloc,ARMRelocator & pParent)914 ARMRelocator::Result got_brel(Relocation& pReloc, ARMRelocator& pParent)
915 {
916 if (!(pReloc.symInfo()->reserved() &
917 (ARMRelocator::ReserveGOT | ARMRelocator::GOTRel))) {
918 return ARMRelocator::BadReloc;
919 }
920 ARMRelocator::Address GOT_S = helper_GOT(pReloc, pParent);
921 ARMRelocator::DWord A = pReloc.target() + pReloc.addend();
922 ARMRelocator::Address GOT_ORG = helper_GOT_ORG(pParent);
923 // Apply relocation.
924 pReloc.target() = GOT_S + A - GOT_ORG;
925 return ARMRelocator::OK;
926 }
927
928 // R_ARM_GOT_PREL: GOT(S) + A - P
got_prel(Relocation & pReloc,ARMRelocator & pParent)929 ARMRelocator::Result got_prel(Relocation& pReloc, ARMRelocator& pParent)
930 {
931 if (!(pReloc.symInfo()->reserved() &
932 (ARMRelocator::ReserveGOT | ARMRelocator::GOTRel))) {
933 return ARMRelocator::BadReloc;
934 }
935 ARMRelocator::Address GOT_S = helper_GOT(pReloc, pParent);
936 ARMRelocator::DWord A = pReloc.target() + pReloc.addend();
937 ARMRelocator::Address P = pReloc.place();
938
939 // Apply relocation.
940 pReloc.target() = GOT_S + A - P;
941 return ARMRelocator::OK;
942 }
943
944 // R_ARM_THM_JUMP11: S + A - P
thm_jump11(Relocation & pReloc,ARMRelocator & pParent)945 ARMRelocator::Result thm_jump11(Relocation& pReloc, ARMRelocator& pParent)
946 {
947 ARMRelocator::DWord P = pReloc.place();
948 ARMRelocator::DWord A =
949 helper_sign_extend((pReloc.target() & 0x07ff) << 1, 11) +
950 pReloc.addend();
951 // S depends on PLT exists or not
952 ARMRelocator::Address S = pReloc.symValue();
953 if (pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT)
954 S = helper_PLT(pReloc, pParent);
955
956 ARMRelocator::DWord X = S + A - P;
957 if (helper_check_signed_overflow(X, 11))
958 return ARMRelocator::Overflow;
959 // Make sure the Imm is 0. Result Mask.
960 pReloc.target() = (pReloc.target() & 0xFFFFF800u) | ((X & 0x0FFEu) >> 1);
961 return ARMRelocator::OK;
962 }
963
964 // R_ARM_PC24: ((S + A) | T) - P
965 // R_ARM_PLT32: ((S + A) | T) - P
966 // R_ARM_JUMP24: ((S + A) | T) - P
967 // R_ARM_CALL: ((S + A) | T) - P
call(Relocation & pReloc,ARMRelocator & pParent)968 ARMRelocator::Result call(Relocation& pReloc, ARMRelocator& pParent)
969 {
970 // If target is undefined weak symbol, we only need to jump to the
971 // next instruction unless it has PLT entry. Rewrite instruction
972 // to NOP.
973 if (pReloc.symInfo()->isWeak() &&
974 pReloc.symInfo()->isUndef() &&
975 !pReloc.symInfo()->isDyn() &&
976 !(pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT)) {
977 // change target to NOP : mov r0, r0
978 pReloc.target() = (pReloc.target() & 0xf0000000U) | 0x01a00000;
979 return ARMRelocator::OK;
980 }
981
982 ARMRelocator::DWord T = getThumbBit(pReloc);
983 ARMRelocator::DWord A =
984 helper_sign_extend((pReloc.target() & 0x00FFFFFFu) << 2, 26) +
985 pReloc.addend();
986 ARMRelocator::Address P = pReloc.place();
987 ARMRelocator::Address S = pReloc.symValue();
988 if (T != 0x0)
989 helper_clear_thumb_bit(S);
990
991 // S depends on PLT exists or not
992 if (pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT) {
993 S = helper_PLT(pReloc, pParent);
994 T = 0; // PLT is not thumb.
995 }
996
997 // At this moment (after relaxation), if the jump target is thumb instruction,
998 // switch mode is needed, rewrite the instruction to BLX
999 // FIXME: check if we can use BLX instruction (check from .ARM.attribute
1000 // CPU ARCH TAG, which should be ARMv5 or above)
1001 if (T != 0) {
1002 // cannot rewrite to blx for R_ARM_JUMP24
1003 if (pReloc.type() == llvm::ELF::R_ARM_JUMP24)
1004 return ARMRelocator::BadReloc;
1005 if (pReloc.type() == llvm::ELF::R_ARM_PC24)
1006 return ARMRelocator::BadReloc;
1007
1008 pReloc.target() = (pReloc.target() & 0xffffff) |
1009 0xfa000000 |
1010 (((S + A - P) & 2) << 23);
1011 }
1012
1013 ARMRelocator::DWord X = ((S + A) | T) - P;
1014 // Check X is 24bit sign int. If not, we should use stub or PLT before apply.
1015 if (helper_check_signed_overflow(X, 26))
1016 return ARMRelocator::Overflow;
1017 // Make sure the Imm is 0. Result Mask.
1018 pReloc.target() = (pReloc.target() & 0xFF000000u) | ((X & 0x03FFFFFEu) >> 2);
1019 return ARMRelocator::OK;
1020 }
1021
1022 // R_ARM_THM_CALL: ((S + A) | T) - P
1023 // R_ARM_THM_JUMP24: ((S + A) | T) - P
thm_call(Relocation & pReloc,ARMRelocator & pParent)1024 ARMRelocator::Result thm_call(Relocation& pReloc, ARMRelocator& pParent)
1025 {
1026 // If target is undefined weak symbol, we only need to jump to the
1027 // next instruction unless it has PLT entry. Rewrite instruction
1028 // to NOP.
1029 if (pReloc.symInfo()->isWeak() &&
1030 pReloc.symInfo()->isUndef() &&
1031 !pReloc.symInfo()->isDyn() &&
1032 !(pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT)) {
1033 pReloc.target() = (0xe000U << 16) | 0xbf00U;
1034 return ARMRelocator::OK;
1035 }
1036
1037 // get lower and upper 16 bit instructions from relocation targetData
1038 uint16_t upper_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()));
1039 uint16_t lower_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1);
1040
1041 ARMRelocator::DWord T = getThumbBit(pReloc);
1042 ARMRelocator::DWord A = helper_thumb32_branch_offset(upper_inst,
1043 lower_inst);
1044 ARMRelocator::Address P = pReloc.place();
1045 ARMRelocator::Address S;
1046
1047 // if symbol has plt
1048 if (pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT) {
1049 S = helper_PLT(pReloc, pParent);
1050 T = 0; // PLT is not thumb.
1051 }
1052 else {
1053 S = pReloc.symValue();
1054 if (T != 0x0)
1055 helper_clear_thumb_bit(S);
1056 }
1057
1058 S = S + A;
1059
1060 // At this moment (after relaxation), if the jump target is arm
1061 // instruction, switch mode is needed, rewrite the instruction to BLX
1062 // FIXME: check if we can use BLX instruction (check from .ARM.attribute
1063 // CPU ARCH TAG, which should be ARMv5 or above)
1064 if (T == 0) {
1065 // cannot rewrite to blx for R_ARM_THM_JUMP24
1066 if (pReloc.type() == llvm::ELF::R_ARM_THM_JUMP24)
1067 return ARMRelocator::BadReloc;
1068
1069 // for BLX, select bit 1 from relocation base address to jump target
1070 // address
1071 S = helper_bit_select(S, P, 0x2);
1072 // rewrite instruction to BLX
1073 lower_inst &= ~0x1000U;
1074 }
1075 else {
1076 // otherwise, the instruction should be BL
1077 lower_inst |= 0x1000U;
1078 }
1079
1080 ARMRelocator::DWord X = (S | T) - P;
1081
1082 // FIXME: Check bit size is 24(thumb2) or 22?
1083 if (helper_check_signed_overflow(X, 25)) {
1084 return ARMRelocator::Overflow;
1085 }
1086
1087 upper_inst = helper_thumb32_branch_upper(upper_inst, X);
1088 lower_inst = helper_thumb32_branch_lower(lower_inst, X);
1089
1090 *(reinterpret_cast<uint16_t*>(&pReloc.target())) = upper_inst;
1091 *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = lower_inst;
1092
1093 return ARMRelocator::OK;
1094 }
1095
1096 // R_ARM_MOVW_ABS_NC: (S + A) | T
movw_abs_nc(Relocation & pReloc,ARMRelocator & pParent)1097 ARMRelocator::Result movw_abs_nc(Relocation& pReloc, ARMRelocator& pParent)
1098 {
1099 ResolveInfo* rsym = pReloc.symInfo();
1100 ARMRelocator::Address S = pReloc.symValue();
1101 ARMRelocator::DWord T = getThumbBit(pReloc);
1102 ARMRelocator::DWord A =
1103 helper_extract_movw_movt_addend(pReloc.target()) + pReloc.addend();
1104 if (T != 0x0)
1105 helper_clear_thumb_bit(S);
1106
1107 LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
1108
1109 // If the flag of target section is not ALLOC, we will not scan this
1110 // relocation but perform static relocation. (e.g., applying .debug section)
1111 if (0x0 != (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
1112 // use plt
1113 if (rsym->reserved() & ARMRelocator::ReservePLT) {
1114 S = helper_PLT(pReloc, pParent);
1115 T = 0 ; // PLT is not thumb
1116 }
1117 }
1118
1119 // perform static relocation
1120 ARMRelocator::DWord X = (S + A) | T;
1121 pReloc.target() = helper_insert_val_movw_movt_inst(
1122 pReloc.target() + pReloc.addend(), X);
1123 return ARMRelocator::OK;
1124 }
1125
1126 // R_ARM_MOVW_PREL_NC: ((S + A) | T) - P
movw_prel_nc(Relocation & pReloc,ARMRelocator & pParent)1127 ARMRelocator::Result movw_prel_nc(Relocation& pReloc, ARMRelocator& pParent)
1128 {
1129 ARMRelocator::Address S = pReloc.symValue();
1130 ARMRelocator::DWord T = getThumbBit(pReloc);
1131 ARMRelocator::DWord P = pReloc.place();
1132 ARMRelocator::DWord A =
1133 helper_extract_movw_movt_addend(pReloc.target()) + pReloc.addend();
1134 if (T != 0x0)
1135 helper_clear_thumb_bit(S);
1136 ARMRelocator::DWord X = ((S + A) | T) - P;
1137
1138 if (helper_check_signed_overflow(X, 16)) {
1139 return ARMRelocator::Overflow;
1140 } else {
1141 pReloc.target() = helper_insert_val_movw_movt_inst(pReloc.target(), X);
1142 return ARMRelocator::OK;
1143 }
1144 }
1145
1146 // R_ARM_MOVT_ABS: S + A
movt_abs(Relocation & pReloc,ARMRelocator & pParent)1147 ARMRelocator::Result movt_abs(Relocation& pReloc, ARMRelocator& pParent)
1148 {
1149 ResolveInfo* rsym = pReloc.symInfo();
1150 ARMRelocator::Address S = pReloc.symValue();
1151 ARMRelocator::DWord A =
1152 helper_extract_movw_movt_addend(pReloc.target()) + pReloc.addend();
1153
1154 LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
1155
1156 // If the flag of target section is not ALLOC, we will not scan this relocation
1157 // but perform static relocation. (e.g., applying .debug section)
1158 if (0x0 != (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
1159 // use plt
1160 if (rsym->reserved() & ARMRelocator::ReservePLT) {
1161 S = helper_PLT(pReloc, pParent);
1162 }
1163 }
1164
1165 ARMRelocator::DWord X = S + A;
1166 X >>= 16;
1167 // perform static relocation
1168 pReloc.target() = helper_insert_val_movw_movt_inst(pReloc.target(), X);
1169 return ARMRelocator::OK;
1170 }
1171
1172 // R_ARM_MOVT_PREL: S + A - P
movt_prel(Relocation & pReloc,ARMRelocator & pParent)1173 ARMRelocator::Result movt_prel(Relocation& pReloc, ARMRelocator& pParent)
1174 {
1175 ARMRelocator::Address S = pReloc.symValue();
1176 ARMRelocator::DWord P = pReloc.place();
1177 ARMRelocator::DWord A =
1178 helper_extract_movw_movt_addend(pReloc.target()) + pReloc.addend();
1179 ARMRelocator::DWord X = S + A - P;
1180 X >>= 16;
1181
1182 pReloc.target() = helper_insert_val_movw_movt_inst(pReloc.target(), X);
1183 return ARMRelocator::OK;
1184 }
1185
1186 // R_ARM_THM_MOVW_ABS_NC: (S + A) | T
thm_movw_abs_nc(Relocation & pReloc,ARMRelocator & pParent)1187 ARMRelocator::Result thm_movw_abs_nc(Relocation& pReloc, ARMRelocator& pParent)
1188 {
1189 ResolveInfo* rsym = pReloc.symInfo();
1190 ARMRelocator::Address S = pReloc.symValue();
1191 ARMRelocator::DWord T = getThumbBit(pReloc);
1192 if (T != 0x0)
1193 helper_clear_thumb_bit(S);
1194
1195 // get lower and upper 16 bit instructions from relocation targetData
1196 uint16_t upper_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()));
1197 uint16_t lower_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1);
1198 ARMRelocator::DWord val = ((upper_inst) << 16) | (lower_inst);
1199 ARMRelocator::DWord A =
1200 helper_extract_thumb_movw_movt_addend(val) + pReloc.addend();
1201
1202 LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
1203 // If the flag of target section is not ALLOC, we will not scan this relocation
1204 // but perform static relocation. (e.g., applying .debug section)
1205 if (0x0 != (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
1206 // use plt
1207 if (rsym->reserved() & ARMRelocator::ReservePLT) {
1208 S = helper_PLT(pReloc, pParent);
1209 T = 0; // PLT is not thumb
1210 }
1211 }
1212 ARMRelocator::DWord X = (S + A) | T;
1213
1214 val = helper_insert_val_thumb_movw_movt_inst(val, X);
1215 *(reinterpret_cast<uint16_t*>(&pReloc.target())) = val >> 16;
1216 *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = val & 0xFFFFu;
1217
1218 return ARMRelocator::OK;
1219 }
1220
1221 // R_ARM_THM_MOVW_PREL_NC: ((S + A) | T) - P
thm_movw_prel_nc(Relocation & pReloc,ARMRelocator & pParent)1222 ARMRelocator::Result thm_movw_prel_nc(Relocation& pReloc, ARMRelocator& pParent)
1223 {
1224 ARMRelocator::Address S = pReloc.symValue();
1225 ARMRelocator::DWord T = getThumbBit(pReloc);
1226 ARMRelocator::DWord P = pReloc.place();
1227 if (T != 0x0)
1228 helper_clear_thumb_bit(S);
1229
1230 // get lower and upper 16 bit instructions from relocation targetData
1231 uint16_t upper_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()));
1232 uint16_t lower_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1);
1233 ARMRelocator::DWord val = ((upper_inst) << 16) | (lower_inst);
1234 ARMRelocator::DWord A =
1235 helper_extract_thumb_movw_movt_addend(val) + pReloc.addend();
1236 ARMRelocator::DWord X = ((S + A) | T) - P;
1237
1238 val = helper_insert_val_thumb_movw_movt_inst(val, X);
1239 *(reinterpret_cast<uint16_t*>(&pReloc.target())) = val >> 16;
1240 *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = val & 0xFFFFu;
1241
1242 return ARMRelocator::OK;
1243 }
1244
1245 // R_ARM_THM_MOVW_BREL_NC: ((S + A) | T) - B(S)
1246 // R_ARM_THM_MOVW_BREL: ((S + A) | T) - B(S)
thm_movw_brel(Relocation & pReloc,ARMRelocator & pParent)1247 ARMRelocator::Result thm_movw_brel(Relocation& pReloc, ARMRelocator& pParent)
1248 {
1249 ARMRelocator::Address S = pReloc.symValue();
1250 ARMRelocator::DWord T = getThumbBit(pReloc);
1251 ARMRelocator::DWord P = pReloc.place();
1252 if (T != 0x0)
1253 helper_clear_thumb_bit(S);
1254
1255 // get lower and upper 16 bit instructions from relocation targetData
1256 uint16_t upper_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()));
1257 uint16_t lower_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1);
1258 ARMRelocator::DWord val = ((upper_inst) << 16) | (lower_inst);
1259 ARMRelocator::DWord A =
1260 helper_extract_thumb_movw_movt_addend(val) + pReloc.addend();
1261
1262 ARMRelocator::DWord X = ((S + A) | T) - P;
1263
1264 val = helper_insert_val_thumb_movw_movt_inst(val, X);
1265 *(reinterpret_cast<uint16_t*>(&pReloc.target())) = val >> 16;
1266 *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = val & 0xFFFFu;
1267
1268 return ARMRelocator::OK;
1269 }
1270
1271 // R_ARM_THM_MOVT_ABS: S + A
thm_movt_abs(Relocation & pReloc,ARMRelocator & pParent)1272 ARMRelocator::Result thm_movt_abs(Relocation& pReloc, ARMRelocator& pParent)
1273 {
1274 ResolveInfo* rsym = pReloc.symInfo();
1275 ARMRelocator::Address S = pReloc.symValue();
1276
1277 // get lower and upper 16 bit instructions from relocation targetData
1278 uint16_t upper_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()));
1279 uint16_t lower_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1);
1280 ARMRelocator::DWord val = ((upper_inst) << 16) | (lower_inst);
1281 ARMRelocator::DWord A =
1282 helper_extract_thumb_movw_movt_addend(val) + pReloc.addend();
1283
1284 LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
1285 // If the flag of target section is not ALLOC, we will not scan this
1286 // relocation but perform static relocation. (e.g., applying .debug section)
1287 if (0x0 != (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
1288 // use plt
1289 if (rsym->reserved() & ARMRelocator::ReservePLT) {
1290 S = helper_PLT(pReloc, pParent);
1291 }
1292 }
1293
1294 ARMRelocator::DWord X = S + A;
1295 X >>= 16;
1296
1297 // check 16-bit overflow
1298 if (helper_check_signed_overflow(X, 16))
1299 return ARMRelocator::Overflow;
1300 val = helper_insert_val_thumb_movw_movt_inst(val, X);
1301 *(reinterpret_cast<uint16_t*>(&pReloc.target())) = val >> 16;
1302 *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = val & 0xFFFFu;
1303 return ARMRelocator::OK;
1304
1305 }
1306
1307 // R_ARM_THM_MOVT_PREL: S + A - P
1308 // R_ARM_THM_MOVT_BREL: S + A - B(S)
thm_movt_prel(Relocation & pReloc,ARMRelocator & pParent)1309 ARMRelocator::Result thm_movt_prel(Relocation& pReloc, ARMRelocator& pParent)
1310 {
1311 ARMRelocator::Address S = pReloc.symValue();
1312 ARMRelocator::DWord P = pReloc.place();
1313
1314 // get lower and upper 16 bit instructions from relocation targetData
1315 uint16_t upper_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()));
1316 uint16_t lower_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1);
1317 ARMRelocator::DWord val = ((upper_inst) << 16) | (lower_inst);
1318 ARMRelocator::DWord A =
1319 helper_extract_thumb_movw_movt_addend(val) + pReloc.addend();
1320 ARMRelocator::DWord X = S + A - P;
1321 X >>= 16;
1322
1323 val = helper_insert_val_thumb_movw_movt_inst(val, X);
1324 *(reinterpret_cast<uint16_t*>(&pReloc.target())) = val >> 16;
1325 *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = val & 0xFFFFu;
1326
1327 return ARMRelocator::OK;
1328 }
1329
1330 // R_ARM_PREL31: ((S + A) | T) - P
prel31(Relocation & pReloc,ARMRelocator & pParent)1331 ARMRelocator::Result prel31(Relocation& pReloc, ARMRelocator& pParent)
1332 {
1333 ARMRelocator::DWord target = pReloc.target();
1334 ARMRelocator::DWord T = getThumbBit(pReloc);
1335 ARMRelocator::DWord A = helper_sign_extend(target, 31) + pReloc.addend();
1336 ARMRelocator::DWord P = pReloc.place();
1337 ARMRelocator::Address S = pReloc.symValue();
1338 if (T != 0x0)
1339 helper_clear_thumb_bit(S);
1340
1341 // if symbol has plt
1342 if ( pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT) {
1343 S = helper_PLT(pReloc, pParent);
1344 T = 0; // PLT is not thumb.
1345 }
1346
1347 ARMRelocator::DWord X = ((S + A) | T) - P;
1348 pReloc.target() = helper_bit_select(target, X, 0x7fffffffU);
1349 if (helper_check_signed_overflow(X, 31))
1350 return ARMRelocator::Overflow;
1351 return ARMRelocator::OK;
1352 }
1353
1354 // R_ARM_TLS_GD32: GOT(S) + A - P
1355 // R_ARM_TLS_IE32: GOT(S) + A - P
1356 // R_ARM_TLS_LE32: S + A - tp
tls(Relocation & pReloc,ARMRelocator & pParent)1357 ARMRelocator::Result tls(Relocation& pReloc, ARMRelocator& pParent)
1358 {
1359 return ARMRelocator::Unsupport;
1360 }
1361
unsupport(Relocation & pReloc,ARMRelocator & pParent)1362 ARMRelocator::Result unsupport(Relocation& pReloc, ARMRelocator& pParent)
1363 {
1364 return ARMRelocator::Unsupport;
1365 }
1366