ARMRelocator.cpp revision f7ac0f19a1c8d0ad14bcf6456ce368b830fea886 
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
22using namespace mcld;
23
24//===--------------------------------------------------------------------===//
25// Relocation Functions and Tables
26//===--------------------------------------------------------------------===//
27DECL_ARM_APPLY_RELOC_FUNCS
28
29/// the prototype of applying function
30typedef Relocator::Result (*ApplyFunctionType)(Relocation& pReloc,
31                                               ARMRelocator& pParent);
32
33// the table entry of applying functions
34struct ApplyFunctionTriple
35{
36  ApplyFunctionType func;
37  unsigned int type;
38  const char* name;
39};
40
41// declare the table of applying functions
42static const ApplyFunctionTriple ApplyFunctions[] = {
43  DECL_ARM_APPLY_RELOC_FUNC_PTRS
44};
45
46//===--------------------------------------------------------------------===//
47// ARMRelocator
48//===--------------------------------------------------------------------===//
49ARMRelocator::ARMRelocator(ARMGNULDBackend& pParent,
50                           const LinkerConfig& pConfig)
51  : Relocator(pConfig),
52    m_Target(pParent) {
53}
54
55ARMRelocator::~ARMRelocator()
56{
57}
58
59Relocator::Result
60ARMRelocator::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
70const char* ARMRelocator::getName(Relocator::Type pType) const
71{
72  return ApplyFunctions[pType].name;
73}
74
75Relocator::Size ARMRelocator::getSize(Relocation::Type pType) const
76{
77  return 32;
78}
79
80void 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.
94LDSymbol&
95ARMRelocator::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.
145void 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
171void
172ARMRelocator::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
271void 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
487void 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//===--------------------------------------------------------------------===//
523static 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.
541static
542uint64_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
554static
555uint64_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
561static bool
562helper_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.
574static inline void helper_clear_thumb_bit(ARMRelocator::DWord& pValue)
575{
576  pValue &= (~0x1);
577}
578
579static
580ARMGOTEntry& 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
622static
623ARMRelocator::Address helper_GOT_ORG(ARMRelocator& pParent)
624{
625  return pParent.getTarget().getGOT().addr();
626}
627
628
629static
630ARMRelocator::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
637static
638ARMPLT1& 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
671static
672ARMRelocator::Address helper_PLT_ORG(ARMRelocator& pParent)
673{
674  return pParent.getTarget().getPLT().addr();
675}
676
677
678static
679ARMRelocator::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()
688static
689void 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
707static ARMRelocator::DWord
708helper_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
715static ARMRelocator::DWord
716helper_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
726static ARMRelocator::DWord
727helper_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
737static ARMRelocator::DWord
738helper_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
750static ARMRelocator::DWord
751helper_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
769static ARMRelocator::DWord
770helper_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
777static ARMRelocator::DWord
778helper_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
789static bool
790helper_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
809ARMRelocator::Result none(Relocation& pReloc, ARMRelocator& pParent)
810{
811  return ARMRelocator::OK;
812}
813
814// R_ARM_ABS32: (S + A) | T
815ARMRelocator::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
867ARMRelocator::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
891ARMRelocator::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
900ARMRelocator::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
914ARMRelocator::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
929ARMRelocator::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
945ARMRelocator::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
968ARMRelocator::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
1024ARMRelocator::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
1097ARMRelocator::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
1127ARMRelocator::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
1147ARMRelocator::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
1173ARMRelocator::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
1187ARMRelocator::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
1222ARMRelocator::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)
1247ARMRelocator::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
1272ARMRelocator::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)
1309ARMRelocator::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
1331ARMRelocator::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
1357ARMRelocator::Result tls(Relocation& pReloc, ARMRelocator& pParent)
1358{
1359  return ARMRelocator::Unsupport;
1360}
1361
1362ARMRelocator::Result unsupport(Relocation& pReloc, ARMRelocator& pParent)
1363{
1364  return ARMRelocator::Unsupport;
1365}
1366