contrib/llvm/tools/lld/lib/ReaderWriter/MachO/ArchHandler_arm.cpp

   1 //===- lib/FileFormat/MachO/ArchHandler_arm.cpp ---------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "ArchHandler.h"
  10 #include "Atoms.h"
  11 #include "MachONormalizedFileBinaryUtils.h"
  12 #include "llvm/ADT/StringRef.h"
  13 #include "llvm/ADT/StringSwitch.h"
  14 #include "llvm/ADT/Triple.h"
  15 #include "llvm/Support/Endian.h"
  16 #include "llvm/Support/ErrorHandling.h"
  17
  18 using namespace llvm::MachO;
  19 using namespace lld::mach_o::normalized;
  20
  21 namespace lld {
  22 namespace mach_o {
  23
  24 using llvm::support::ulittle32_t;
  25 using llvm::support::little32_t;
  26
  27
  28 class ArchHandler_arm : public ArchHandler {
  29 public:
  30   ArchHandler_arm() = default;
  31   ~ArchHandler_arm() override = default;
  32
  33   const Registry::KindStrings *kindStrings() override { return _sKindStrings; }
  34
  35   Reference::KindArch kindArch() override { return Reference::KindArch::ARM; }
  36
  37   const ArchHandler::StubInfo &stubInfo() override;
  38   bool isCallSite(const Reference &) override;
  39   bool isPointer(const Reference &) override;
  40   bool isPairedReloc(const normalized::Relocation &) override;
  41   bool isNonCallBranch(const Reference &) override;
  42
  43   bool needsCompactUnwind() override {
  44     return false;
  45   }
  46   Reference::KindValue imageOffsetKind() override {
  47     return invalid;
  48   }
  49   Reference::KindValue imageOffsetKindIndirect() override {
  50     return invalid;
  51   }
  52
  53   Reference::KindValue unwindRefToPersonalityFunctionKind() override {
  54     return invalid;
  55   }
  56
  57   Reference::KindValue unwindRefToCIEKind() override {
  58     return invalid;
  59   }
  60
  61   Reference::KindValue unwindRefToFunctionKind() override {
  62     return invalid;
  63   }
  64
  65   Reference::KindValue unwindRefToEhFrameKind() override {
  66     return invalid;
  67   }
  68
  69   Reference::KindValue lazyImmediateLocationKind() override {
  70     return lazyImmediateLocation;
  71   }
  72
  73   Reference::KindValue pointerKind() override {
  74     return invalid;
  75   }
  76
  77   uint32_t dwarfCompactUnwindType() override {
  78     // FIXME
  79     return -1;
  80   }
  81
  82   llvm::Error getReferenceInfo(const normalized::Relocation &reloc,
  83                                const DefinedAtom *inAtom,
  84                                uint32_t offsetInAtom,
  85                                uint64_t fixupAddress, bool swap,
  86                                FindAtomBySectionAndAddress atomFromAddress,
  87                                FindAtomBySymbolIndex atomFromSymbolIndex,
  88                                Reference::KindValue *kind,
  89                                const lld::Atom **target,
  90                                Reference::Addend *addend) override;
  91   llvm::Error
  92       getPairReferenceInfo(const normalized::Relocation &reloc1,
  93                            const normalized::Relocation &reloc2,
  94                            const DefinedAtom *inAtom,
  95                            uint32_t offsetInAtom,
  96                            uint64_t fixupAddress, bool swap, bool scatterable,
  97                            FindAtomBySectionAndAddress atomFromAddress,
  98                            FindAtomBySymbolIndex atomFromSymbolIndex,
  99                            Reference::KindValue *kind,
 100                            const lld::Atom **target,
 101                            Reference::Addend *addend) override;
 102
 103   void generateAtomContent(const DefinedAtom &atom, bool relocatable,
 104                            FindAddressForAtom findAddress,
 105                            FindAddressForAtom findSectionAddress,
 106                            uint64_t imageBaseAddress,
 107                            llvm::MutableArrayRef<uint8_t> atomContentBuffer) override;
 108
 109   void appendSectionRelocations(const DefinedAtom &atom,
 110                                 uint64_t atomSectionOffset,
 111                                 const Reference &ref,
 112                                 FindSymbolIndexForAtom,
 113                                 FindSectionIndexForAtom,
 114                                 FindAddressForAtom,
 115                                 normalized::Relocations &) override;
 116
 117   void addAdditionalReferences(MachODefinedAtom &atom) override;
 118
 119   bool isDataInCodeTransition(Reference::KindValue refKind) override {
 120     switch (refKind) {
 121     case modeThumbCode:
 122     case modeArmCode:
 123     case modeData:
 124       return true;
 125     default:
 126       return false;
 127       break;
 128     }
 129   }
 130
 131   Reference::KindValue dataInCodeTransitionStart(
 132                                         const MachODefinedAtom &atom) override {
 133     return modeData;
 134   }
 135
 136   Reference::KindValue dataInCodeTransitionEnd(
 137                                         const MachODefinedAtom &atom) override {
 138     return atom.isThumb() ? modeThumbCode : modeArmCode;
 139   }
 140
 141   bool isThumbFunction(const DefinedAtom &atom) override;
 142   const DefinedAtom *createShim(MachOFile &file, bool thumbToArm,
 143                                 const DefinedAtom &) override;
 144
 145 private:
 146   friend class Thumb2ToArmShimAtom;
 147   friend class ArmToThumbShimAtom;
 148
 149   static const Registry::KindStrings _sKindStrings[];
 150   static const StubInfo              _sStubInfoArmPIC;
 151
 152   enum ArmKind : Reference::KindValue {
 153     invalid,               /// for error condition
 154
 155     modeThumbCode,         /// Content starting at this offset is thumb.
 156     modeArmCode,           /// Content starting at this offset is arm.
 157     modeData,              /// Content starting at this offset is data.
 158
 159     // Kinds found in mach-o .o files:
 160     thumb_bl22,            /// ex: bl _foo
 161     thumb_b22,             /// ex: b _foo
 162     thumb_movw,            /// ex: movw r1, :lower16:_foo
 163     thumb_movt,            /// ex: movt r1, :lower16:_foo
 164     thumb_movw_funcRel,    /// ex: movw r1, :lower16:(_foo-(L1+4))
 165     thumb_movt_funcRel,    /// ex: movt r1, :upper16:(_foo-(L1+4))
 166     arm_bl24,              /// ex: bl _foo
 167     arm_b24,               /// ex: b _foo
 168     arm_movw,              /// ex: movw r1, :lower16:_foo
 169     arm_movt,              /// ex: movt r1, :lower16:_foo
 170     arm_movw_funcRel,      /// ex: movw r1, :lower16:(_foo-(L1+4))
 171     arm_movt_funcRel,      /// ex: movt r1, :upper16:(_foo-(L1+4))
 172     pointer32,             /// ex: .long _foo
 173     delta32,               /// ex: .long _foo - .
 174
 175     // Kinds introduced by Passes:
 176     lazyPointer,           /// Location contains a lazy pointer.
 177     lazyImmediateLocation, /// Location contains immediate value used in stub.
 178   };
 179
 180   // Utility functions for inspecting/updating instructions.
 181   static bool isThumbMovw(uint32_t instruction);
 182   static bool isThumbMovt(uint32_t instruction);
 183   static bool isArmMovw(uint32_t instruction);
 184   static bool isArmMovt(uint32_t instruction);
 185   static int32_t getDisplacementFromThumbBranch(uint32_t instruction, uint32_t);
 186   static int32_t getDisplacementFromArmBranch(uint32_t instruction);
 187   static uint16_t getWordFromThumbMov(uint32_t instruction);
 188   static uint16_t getWordFromArmMov(uint32_t instruction);
 189   static uint32_t clearThumbBit(uint32_t value, const Atom *target);
 190   static uint32_t setDisplacementInArmBranch(uint32_t instr, int32_t disp,
 191                                              bool targetIsThumb);
 192   static uint32_t setDisplacementInThumbBranch(uint32_t instr, uint32_t ia,
 193                                                int32_t disp, bool targetThumb);
 194   static uint32_t setWordFromThumbMov(uint32_t instruction, uint16_t word);
 195   static uint32_t setWordFromArmMov(uint32_t instruction, uint16_t word);
 196
 197   StringRef stubName(const DefinedAtom &);
 198   bool useExternalRelocationTo(const Atom &target);
 199
 200   void applyFixupFinal(const Reference &ref, uint8_t *location,
 201                        uint64_t fixupAddress, uint64_t targetAddress,
 202                        uint64_t inAtomAddress, bool &thumbMode,
 203                        bool targetIsThumb);
 204
 205   void applyFixupRelocatable(const Reference &ref, uint8_t *location,
 206                              uint64_t fixupAddress,
 207                              uint64_t targetAddress,
 208                              uint64_t inAtomAddress, bool &thumbMode,
 209                              bool targetIsThumb);
 210 };
 211
 212 //===----------------------------------------------------------------------===//
 213 //  ArchHandler_arm
 214 //===----------------------------------------------------------------------===//
 215
 216 const Registry::KindStrings ArchHandler_arm::_sKindStrings[] = {
 217   LLD_KIND_STRING_ENTRY(invalid),
 218   LLD_KIND_STRING_ENTRY(modeThumbCode),
 219   LLD_KIND_STRING_ENTRY(modeArmCode),
 220   LLD_KIND_STRING_ENTRY(modeData),
 221   LLD_KIND_STRING_ENTRY(thumb_bl22),
 222   LLD_KIND_STRING_ENTRY(thumb_b22),
 223   LLD_KIND_STRING_ENTRY(thumb_movw),
 224   LLD_KIND_STRING_ENTRY(thumb_movt),
 225   LLD_KIND_STRING_ENTRY(thumb_movw_funcRel),
 226   LLD_KIND_STRING_ENTRY(thumb_movt_funcRel),
 227   LLD_KIND_STRING_ENTRY(arm_bl24),
 228   LLD_KIND_STRING_ENTRY(arm_b24),
 229   LLD_KIND_STRING_ENTRY(arm_movw),
 230   LLD_KIND_STRING_ENTRY(arm_movt),
 231   LLD_KIND_STRING_ENTRY(arm_movw_funcRel),
 232   LLD_KIND_STRING_ENTRY(arm_movt_funcRel),
 233   LLD_KIND_STRING_ENTRY(pointer32),
 234   LLD_KIND_STRING_ENTRY(delta32),
 235   LLD_KIND_STRING_ENTRY(lazyPointer),
 236   LLD_KIND_STRING_ENTRY(lazyImmediateLocation),
 237   LLD_KIND_STRING_END
 238 };
 239
 240 const ArchHandler::StubInfo ArchHandler_arm::_sStubInfoArmPIC = {
 241   "dyld_stub_binder",
 242
 243   // References in lazy pointer
 244   { Reference::KindArch::ARM, pointer32, 0, 0 },
 245   { Reference::KindArch::ARM, lazyPointer, 0, 0 },
 246
 247   // GOT pointer to dyld_stub_binder
 248   { Reference::KindArch::ARM, pointer32, 0, 0 },
 249
 250   // arm code alignment 2^2
 251   2,
 252
 253   // Stub size and code
 254   16,
 255   { 0x04, 0xC0, 0x9F, 0xE5,       //    ldr ip, pc + 12
 256     0x0C, 0xC0, 0x8F, 0xE0,       //  add ip, pc, ip
 257     0x00, 0xF0, 0x9C, 0xE5,       //    ldr pc, [ip]
 258     0x00, 0x00, 0x00, 0x00 },     //    .long L_foo$lazy_ptr - (L1$scv + 8)
 259   { Reference::KindArch::ARM, delta32, 12, 0 },
 260   { false, 0, 0, 0 },
 261
 262   // Stub Helper size and code
 263   12,
 264   { 0x00, 0xC0, 0x9F, 0xE5,       // ldr   ip, [pc, #0]
 265     0x00, 0x00, 0x00, 0xEA,       // b       _helperhelper
 266     0x00, 0x00, 0x00, 0x00 },     // .long  lazy-info-offset
 267   { Reference::KindArch::ARM, lazyImmediateLocation, 8, 0 },
 268   { Reference::KindArch::ARM, arm_b24, 4, 0 },
 269
 270   // Stub helper image cache content type
 271   DefinedAtom::typeGOT,
 272
 273   // Stub Helper-Common size and code
 274   36,
 275   // Stub helper alignment
 276   2,
 277         { // push lazy-info-offset
 278     0x04, 0xC0, 0x2D, 0xE5,       // str ip, [sp, #-4]!
 279                 // push address of dyld_mageLoaderCache
 280     0x10, 0xC0, 0x9F, 0xE5,       // ldr        ip, L1
 281     0x0C, 0xC0, 0x8F, 0xE0,       // add        ip, pc, ip
 282     0x04, 0xC0, 0x2D, 0xE5,       // str ip, [sp, #-4]!
 283                 // jump through dyld_stub_binder
 284     0x08, 0xC0, 0x9F, 0xE5,       // ldr        ip, L2
 285     0x0C, 0xC0, 0x8F, 0xE0,       // add        ip, pc, ip
 286     0x00, 0xF0, 0x9C, 0xE5,       // ldr        pc, [ip]
 287     0x00, 0x00, 0x00, 0x00,       // L1: .long fFastStubGOTAtom - (helper+16)
 288     0x00, 0x00, 0x00, 0x00 },     // L2: .long dyld_stub_binder - (helper+28)
 289   { Reference::KindArch::ARM, delta32, 28, 0xC },
 290   { false, 0, 0, 0 },
 291   { Reference::KindArch::ARM, delta32, 32, 0x04 },
 292   { false, 0, 0, 0 }
 293 };
 294
 295 const ArchHandler::StubInfo &ArchHandler_arm::stubInfo() {
 296   // If multiple kinds of stubs are supported, select which StubInfo here.
 297   return _sStubInfoArmPIC;
 298 }
 299
 300 bool ArchHandler_arm::isCallSite(const Reference &ref) {
 301   switch (ref.kindValue()) {
 302   case thumb_b22:
 303   case thumb_bl22:
 304   case arm_b24:
 305   case arm_bl24:
 306     return true;
 307   default:
 308     return false;
 309   }
 310 }
 311
 312 bool ArchHandler_arm::isPointer(const Reference &ref) {
 313   return (ref.kindValue() == pointer32);
 314 }
 315
 316 bool ArchHandler_arm::isNonCallBranch(const Reference &ref) {
 317   switch (ref.kindValue()) {
 318   case thumb_b22:
 319   case arm_b24:
 320     return true;
 321   default:
 322     return false;
 323   }
 324 }
 325
 326 bool ArchHandler_arm::isPairedReloc(const Relocation &reloc) {
 327   switch (reloc.type) {
 328   case ARM_RELOC_SECTDIFF:
 329   case ARM_RELOC_LOCAL_SECTDIFF:
 330   case ARM_RELOC_HALF_SECTDIFF:
 331   case ARM_RELOC_HALF:
 332     return true;
 333   default:
 334     return false;
 335   }
 336 }
 337
 338 /// Trace references from stub atom to lazy pointer to target and get its name.
 339 StringRef ArchHandler_arm::stubName(const DefinedAtom &stubAtom) {
 340   assert(stubAtom.contentType() == DefinedAtom::typeStub);
 341   for (const Reference *ref : stubAtom) {
 342     if (const DefinedAtom* lp = dyn_cast<DefinedAtom>(ref->target())) {
 343       if (lp->contentType() != DefinedAtom::typeLazyPointer)
 344         continue;
 345       for (const Reference *ref2 : *lp) {
 346         if (ref2->kindValue() != lazyPointer)
 347           continue;
 348         return ref2->target()->name();
 349       }
 350     }
 351   }
 352   return "stub";
 353 }
 354
 355 /// Extract displacement from an ARM b/bl/blx instruction.
 356 int32_t ArchHandler_arm::getDisplacementFromArmBranch(uint32_t instruction) {
 357   // Sign-extend imm24
 358   int32_t displacement = (instruction & 0x00FFFFFF) << 2;
 359   if ((displacement & 0x02000000) != 0)
 360     displacement |= 0xFC000000;
 361   // If this is BLX and H bit set, add 2.
 362   if ((instruction & 0xFF000000) == 0xFB000000)
 363     displacement += 2;
 364   return displacement;
 365 }
 366
 367 /// Update an ARM b/bl/blx instruction, switching bl <-> blx as needed.
 368 uint32_t ArchHandler_arm::setDisplacementInArmBranch(uint32_t instruction,
 369                                                      int32_t displacement,
 370                                                      bool targetIsThumb) {
 371   assert((displacement <= 33554428) && (displacement > (-33554432))
 372                                               && "arm branch out of range");
 373   bool is_blx = ((instruction & 0xF0000000) == 0xF0000000);
 374   uint32_t newInstruction = (instruction & 0xFF000000);
 375   uint32_t h = 0;
 376   if (targetIsThumb) {
 377     // Force use of BLX.
 378     newInstruction = 0xFA000000;
 379     if (!is_blx) {
 380       assert(((instruction & 0xF0000000) == 0xE0000000)
 381                                                    && "no conditional arm blx");
 382       assert(((instruction & 0xFF000000) == 0xEB000000)
 383                                              && "no arm pc-rel BX instruction");
 384     }
 385     if (displacement & 2)
 386       h = 1;
 387   }
 388   else {
 389     // Force use of B/BL.
 390     if (is_blx)
 391       newInstruction = 0xEB000000;
 392   }
 393   newInstruction |= (h << 24) | ((displacement >> 2) & 0x00FFFFFF);
 394   return newInstruction;
 395 }
 396
 397 /// Extract displacement from a thumb b/bl/blx instruction.
 398 int32_t ArchHandler_arm::getDisplacementFromThumbBranch(uint32_t instruction,
 399                                                         uint32_t instrAddr) {
 400   bool is_blx = ((instruction & 0xD000F800) == 0xC000F000);
 401   uint32_t s = (instruction >> 10) & 0x1;
 402   uint32_t j1 = (instruction >> 29) & 0x1;
 403   uint32_t j2 = (instruction >> 27) & 0x1;
 404   uint32_t imm10 = instruction & 0x3FF;
 405   uint32_t imm11 = (instruction >> 16) & 0x7FF;
 406   uint32_t i1 = (j1 == s);
 407   uint32_t i2 = (j2 == s);
 408   uint32_t dis =
 409       (s << 24) | (i1 << 23) | (i2 << 22) | (imm10 << 12) | (imm11 << 1);
 410   int32_t sdis = dis;
 411   int32_t result = s ? (sdis | 0xFE000000) : sdis;
 412   if (is_blx && (instrAddr & 0x2)) {
 413     // The thumb blx instruction always has low bit of imm11 as zero.  The way
 414     // a 2-byte aligned blx can branch to a 4-byte aligned ARM target is that
 415     // the blx instruction always 4-byte aligns the pc before adding the
 416     // displacement from the blx.  We must emulate that when decoding this.
 417     result -= 2;
 418   }
 419   return result;
 420 }
 421
 422 /// Update a thumb b/bl/blx instruction, switching bl <-> blx as needed.
 423 uint32_t ArchHandler_arm::setDisplacementInThumbBranch(uint32_t instruction,
 424                                                        uint32_t instrAddr,
 425                                                        int32_t displacement,
 426                                                        bool targetIsThumb) {
 427   assert((displacement <= 16777214) && (displacement > (-16777216))
 428                                               && "thumb branch out of range");
 429         bool is_bl = ((instruction & 0xD000F800) == 0xD000F000);
 430         bool is_blx = ((instruction & 0xD000F800) == 0xC000F000);
 431         bool is_b = ((instruction & 0xD000F800) == 0x9000F000);
 432   uint32_t newInstruction = (instruction & 0xD000F800);
 433   if (is_bl || is_blx) {
 434     if (targetIsThumb) {
 435       newInstruction = 0xD000F000; // Use bl
 436     } else {
 437       newInstruction = 0xC000F000; // Use blx
 438       // See note in getDisplacementFromThumbBranch() about blx.
 439       if (instrAddr & 0x2)
 440         displacement += 2;
 441     }
 442   } else if (is_b) {
 443     assert(targetIsThumb && "no pc-rel thumb branch instruction that "
 444                              "switches to arm mode");
 445   }
 446   else {
 447     llvm_unreachable("thumb branch22 reloc on a non-branch instruction");
 448   }
 449   uint32_t s = (uint32_t)(displacement >> 24) & 0x1;
 450   uint32_t i1 = (uint32_t)(displacement >> 23) & 0x1;
 451   uint32_t i2 = (uint32_t)(displacement >> 22) & 0x1;
 452   uint32_t imm10 = (uint32_t)(displacement >> 12) & 0x3FF;
 453   uint32_t imm11 = (uint32_t)(displacement >> 1) & 0x7FF;
 454   uint32_t j1 = (i1 == s);
 455   uint32_t j2 = (i2 == s);
 456   uint32_t nextDisp = (j1 << 13) | (j2 << 11) | imm11;
 457   uint32_t firstDisp = (s << 10) | imm10;
 458   newInstruction |= (nextDisp << 16) | firstDisp;
 459   return newInstruction;
 460 }
 461
 462 bool ArchHandler_arm::isThumbMovw(uint32_t instruction) {
 463   return (instruction & 0x8000FBF0) == 0x0000F240;
 464 }
 465
 466 bool ArchHandler_arm::isThumbMovt(uint32_t instruction) {
 467   return (instruction & 0x8000FBF0) == 0x0000F2C0;
 468 }
 469
 470 bool ArchHandler_arm::isArmMovw(uint32_t instruction) {
 471   return (instruction & 0x0FF00000) == 0x03000000;
 472 }
 473
 474 bool ArchHandler_arm::isArmMovt(uint32_t instruction) {
 475   return (instruction & 0x0FF00000) == 0x03400000;
 476 }
 477
 478 uint16_t ArchHandler_arm::getWordFromThumbMov(uint32_t instruction) {
 479   assert(isThumbMovw(instruction) || isThumbMovt(instruction));
 480   uint32_t i = ((instruction & 0x00000400) >> 10);
 481   uint32_t imm4 = (instruction & 0x0000000F);
 482   uint32_t imm3 = ((instruction & 0x70000000) >> 28);
 483   uint32_t imm8 = ((instruction & 0x00FF0000) >> 16);
 484   return (imm4 << 12) | (i << 11) | (imm3 << 8) | imm8;
 485 }
 486
 487 uint16_t ArchHandler_arm::getWordFromArmMov(uint32_t instruction) {
 488   assert(isArmMovw(instruction) || isArmMovt(instruction));
 489   uint32_t imm4 = ((instruction & 0x000F0000) >> 16);
 490   uint32_t imm12 = (instruction & 0x00000FFF);
 491   return (imm4 << 12) | imm12;
 492 }
 493
 494 uint32_t ArchHandler_arm::setWordFromThumbMov(uint32_t instr, uint16_t word) {
 495   assert(isThumbMovw(instr) || isThumbMovt(instr));
 496   uint32_t imm4 = (word & 0xF000) >> 12;
 497   uint32_t i =    (word & 0x0800) >> 11;
 498   uint32_t imm3 = (word & 0x0700) >> 8;
 499   uint32_t imm8 =  word & 0x00FF;
 500         return (instr & 0x8F00FBF0) | imm4 | (i << 10) | (imm3 << 28) | (imm8 << 16);
 501 }
 502
 503 uint32_t ArchHandler_arm::setWordFromArmMov(uint32_t instr, uint16_t word) {
 504   assert(isArmMovw(instr) || isArmMovt(instr));
 505   uint32_t imm4 = (word & 0xF000) >> 12;
 506   uint32_t imm12 = word & 0x0FFF;
 507   return (instr & 0xFFF0F000) | (imm4 << 16) | imm12;
 508 }
 509
 510 uint32_t ArchHandler_arm::clearThumbBit(uint32_t value, const Atom *target) {
 511   // The assembler often adds one to the address of a thumb function.
 512   // We need to undo that so it does not look like an addend.
 513   if (value & 1) {
 514     if (isa<DefinedAtom>(target)) {
 515       const MachODefinedAtom *machoTarget =
 516           reinterpret_cast<const MachODefinedAtom *>(target);
 517       if (machoTarget->isThumb())
 518         value &= -2; // mask off thumb-bit
 519     }
 520   }
 521   return value;
 522 }
 523
 524 llvm::Error ArchHandler_arm::getReferenceInfo(
 525     const Relocation &reloc, const DefinedAtom *inAtom, uint32_t offsetInAtom,
 526     uint64_t fixupAddress, bool isBig,
 527     FindAtomBySectionAndAddress atomFromAddress,
 528     FindAtomBySymbolIndex atomFromSymbolIndex, Reference::KindValue *kind,
 529     const lld::Atom **target, Reference::Addend *addend) {
 530   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
 531   uint64_t targetAddress;
 532   uint32_t instruction = *(const ulittle32_t *)fixupContent;
 533   int32_t displacement;
 534   switch (relocPattern(reloc)) {
 535   case ARM_THUMB_RELOC_BR22 | rPcRel | rExtern | rLength4:
 536     // ex: bl _foo (and _foo is undefined)
 537     if ((instruction & 0xD000F800) == 0x9000F000)
 538       *kind = thumb_b22;
 539     else
 540       *kind = thumb_bl22;
 541     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
 542       return ec;
 543     // Instruction contains branch to addend.
 544     displacement = getDisplacementFromThumbBranch(instruction, fixupAddress);
 545     *addend = fixupAddress + 4 + displacement;
 546     return llvm::Error::success();
 547   case ARM_THUMB_RELOC_BR22 | rPcRel | rLength4:
 548     // ex: bl _foo (and _foo is defined)
 549     if ((instruction & 0xD000F800) == 0x9000F000)
 550       *kind = thumb_b22;
 551     else
 552       *kind = thumb_bl22;
 553     displacement = getDisplacementFromThumbBranch(instruction, fixupAddress);
 554     targetAddress = fixupAddress + 4 + displacement;
 555     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
 556   case ARM_THUMB_RELOC_BR22 | rScattered | rPcRel | rLength4:
 557     // ex: bl _foo+4 (and _foo is defined)
 558     if ((instruction & 0xD000F800) == 0x9000F000)
 559       *kind = thumb_b22;
 560     else
 561       *kind = thumb_bl22;
 562     displacement = getDisplacementFromThumbBranch(instruction, fixupAddress);
 563     targetAddress = fixupAddress + 4 + displacement;
 564     if (auto ec = atomFromAddress(0, reloc.value, target, addend))
 565       return ec;
 566     // reloc.value is target atom's address.  Instruction contains branch
 567     // to atom+addend.
 568     *addend += (targetAddress - reloc.value);
 569     return llvm::Error::success();
 570   case ARM_RELOC_BR24 | rPcRel | rExtern | rLength4:
 571     // ex: bl _foo (and _foo is undefined)
 572     if (((instruction & 0x0F000000) == 0x0A000000)
 573         && ((instruction & 0xF0000000) != 0xF0000000))
 574       *kind = arm_b24;
 575     else
 576       *kind = arm_bl24;
 577     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
 578       return ec;
 579     // Instruction contains branch to addend.
 580     displacement = getDisplacementFromArmBranch(instruction);
 581     *addend = fixupAddress + 8 + displacement;
 582     return llvm::Error::success();
 583   case ARM_RELOC_BR24 | rPcRel | rLength4:
 584     // ex: bl _foo (and _foo is defined)
 585     if (((instruction & 0x0F000000) == 0x0A000000)
 586         && ((instruction & 0xF0000000) != 0xF0000000))
 587       *kind = arm_b24;
 588     else
 589       *kind = arm_bl24;
 590     displacement = getDisplacementFromArmBranch(instruction);
 591     targetAddress = fixupAddress + 8 + displacement;
 592     return atomFromAddress(reloc.symbol, targetAddress, target, addend);
 593   case ARM_RELOC_BR24 | rScattered | rPcRel | rLength4:
 594     // ex: bl _foo+4 (and _foo is defined)
 595     if (((instruction & 0x0F000000) == 0x0A000000)
 596         && ((instruction & 0xF0000000) != 0xF0000000))
 597       *kind = arm_b24;
 598     else
 599       *kind = arm_bl24;
 600     displacement = getDisplacementFromArmBranch(instruction);
 601     targetAddress = fixupAddress + 8 + displacement;
 602     if (auto ec = atomFromAddress(0, reloc.value, target, addend))
 603       return ec;
 604     // reloc.value is target atom's address.  Instruction contains branch
 605     // to atom+addend.
 606     *addend += (targetAddress - reloc.value);
 607     return llvm::Error::success();
 608   case ARM_RELOC_VANILLA | rExtern | rLength4:
 609     // ex: .long _foo (and _foo is undefined)
 610     *kind = pointer32;
 611     if (auto ec = atomFromSymbolIndex(reloc.symbol, target))
 612       return ec;
 613     *addend = instruction;
 614     return llvm::Error::success();
 615   case ARM_RELOC_VANILLA | rLength4:
 616     // ex: .long _foo (and _foo is defined)
 617     *kind = pointer32;
 618     if (auto ec = atomFromAddress(reloc.symbol, instruction, target, addend))
 619       return ec;
 620     *addend = clearThumbBit((uint32_t) * addend, *target);
 621     return llvm::Error::success();
 622   case ARM_RELOC_VANILLA | rScattered | rLength4:
 623     // ex: .long _foo+a (and _foo is defined)
 624     *kind = pointer32;
 625     if (auto ec = atomFromAddress(0, reloc.value, target, addend))
 626       return ec;
 627     *addend += (clearThumbBit(instruction, *target) - reloc.value);
 628     return llvm::Error::success();
 629   default:
 630     return llvm::make_error<GenericError>("unsupported arm relocation type");
 631   }
 632   return llvm::Error::success();
 633 }
 634
 635 llvm::Error
 636 ArchHandler_arm::getPairReferenceInfo(const normalized::Relocation &reloc1,
 637                                      const normalized::Relocation &reloc2,
 638                                      const DefinedAtom *inAtom,
 639                                      uint32_t offsetInAtom,
 640                                      uint64_t fixupAddress, bool isBig,
 641                                      bool scatterable,
 642                                      FindAtomBySectionAndAddress atomFromAddr,
 643                                      FindAtomBySymbolIndex atomFromSymbolIndex,
 644                                      Reference::KindValue *kind,
 645                                      const lld::Atom **target,
 646                                      Reference::Addend *addend) {
 647   bool pointerDiff = false;
 648   bool funcRel;
 649   bool top;
 650   bool thumbReloc;
 651   switch(relocPattern(reloc1) << 16 | relocPattern(reloc2)) {
 652   case ((ARM_RELOC_HALF_SECTDIFF  | rScattered | rLenThmbLo) << 16 |
 653          ARM_RELOC_PAIR           | rScattered | rLenThmbLo):
 654     // ex: movw r1, :lower16:(_x-L1) [thumb mode]
 655     *kind = thumb_movw_funcRel;
 656     funcRel = true;
 657     top = false;
 658     thumbReloc = true;
 659     break;
 660   case ((ARM_RELOC_HALF_SECTDIFF  | rScattered | rLenThmbHi) << 16 |
 661          ARM_RELOC_PAIR           | rScattered | rLenThmbHi):
 662     // ex: movt r1, :upper16:(_x-L1) [thumb mode]
 663     *kind = thumb_movt_funcRel;
 664     funcRel = true;
 665     top = true;
 666     thumbReloc = true;
 667     break;
 668   case ((ARM_RELOC_HALF_SECTDIFF  | rScattered | rLenArmLo) << 16 |
 669          ARM_RELOC_PAIR           | rScattered | rLenArmLo):
 670     // ex: movw r1, :lower16:(_x-L1) [arm mode]
 671     *kind = arm_movw_funcRel;
 672     funcRel = true;
 673     top = false;
 674     thumbReloc = false;
 675     break;
 676   case ((ARM_RELOC_HALF_SECTDIFF  | rScattered | rLenArmHi) << 16 |
 677          ARM_RELOC_PAIR           | rScattered | rLenArmHi):
 678     // ex: movt r1, :upper16:(_x-L1) [arm mode]
 679     *kind = arm_movt_funcRel;
 680     funcRel = true;
 681     top = true;
 682     thumbReloc = false;
 683     break;
 684   case ((ARM_RELOC_HALF     | rLenThmbLo) << 16 |
 685          ARM_RELOC_PAIR     | rLenThmbLo):
 686     // ex: movw r1, :lower16:_x [thumb mode]
 687     *kind = thumb_movw;
 688     funcRel = false;
 689     top = false;
 690     thumbReloc = true;
 691     break;
 692   case ((ARM_RELOC_HALF     | rLenThmbHi) << 16 |
 693          ARM_RELOC_PAIR     | rLenThmbHi):
 694     // ex: movt r1, :upper16:_x [thumb mode]
 695     *kind = thumb_movt;
 696     funcRel = false;
 697     top = true;
 698     thumbReloc = true;
 699     break;
 700   case ((ARM_RELOC_HALF     | rLenArmLo) << 16 |
 701          ARM_RELOC_PAIR     | rLenArmLo):
 702     // ex: movw r1, :lower16:_x [arm mode]
 703     *kind = arm_movw;
 704     funcRel = false;
 705     top = false;
 706     thumbReloc = false;
 707     break;
 708   case ((ARM_RELOC_HALF     | rLenArmHi) << 16 |
 709          ARM_RELOC_PAIR     | rLenArmHi):
 710     // ex: movt r1, :upper16:_x [arm mode]
 711     *kind = arm_movt;
 712     funcRel = false;
 713     top = true;
 714     thumbReloc = false;
 715     break;
 716   case ((ARM_RELOC_HALF | rScattered  | rLenThmbLo) << 16 |
 717          ARM_RELOC_PAIR               | rLenThmbLo):
 718     // ex: movw r1, :lower16:_x+a [thumb mode]
 719     *kind = thumb_movw;
 720     funcRel = false;
 721     top = false;
 722     thumbReloc = true;
 723     break;
 724   case ((ARM_RELOC_HALF | rScattered  | rLenThmbHi) << 16 |
 725          ARM_RELOC_PAIR               | rLenThmbHi):
 726     // ex: movt r1, :upper16:_x+a [thumb mode]
 727     *kind = thumb_movt;
 728     funcRel = false;
 729     top = true;
 730     thumbReloc = true;
 731     break;
 732   case ((ARM_RELOC_HALF | rScattered  | rLenArmLo) << 16 |
 733          ARM_RELOC_PAIR               | rLenArmLo):
 734     // ex: movw r1, :lower16:_x+a [arm mode]
 735     *kind = arm_movw;
 736     funcRel = false;
 737     top = false;
 738     thumbReloc = false;
 739     break;
 740   case ((ARM_RELOC_HALF | rScattered  | rLenArmHi) << 16 |
 741          ARM_RELOC_PAIR               | rLenArmHi):
 742     // ex: movt r1, :upper16:_x+a [arm mode]
 743     *kind = arm_movt;
 744     funcRel = false;
 745     top = true;
 746     thumbReloc = false;
 747     break;
 748   case ((ARM_RELOC_HALF | rExtern   | rLenThmbLo) << 16 |
 749          ARM_RELOC_PAIR             | rLenThmbLo):
 750     // ex: movw r1, :lower16:_undef [thumb mode]
 751     *kind = thumb_movw;
 752     funcRel = false;
 753     top = false;
 754     thumbReloc = true;
 755     break;
 756   case ((ARM_RELOC_HALF | rExtern   | rLenThmbHi) << 16 |
 757          ARM_RELOC_PAIR             | rLenThmbHi):
 758     // ex: movt r1, :upper16:_undef [thumb mode]
 759     *kind = thumb_movt;
 760     funcRel = false;
 761     top = true;
 762     thumbReloc = true;
 763     break;
 764   case ((ARM_RELOC_HALF | rExtern   | rLenArmLo) << 16 |
 765          ARM_RELOC_PAIR             | rLenArmLo):
 766     // ex: movw r1, :lower16:_undef [arm mode]
 767     *kind = arm_movw;
 768     funcRel = false;
 769     top = false;
 770     thumbReloc = false;
 771     break;
 772   case ((ARM_RELOC_HALF | rExtern   | rLenArmHi) << 16 |
 773          ARM_RELOC_PAIR             | rLenArmHi):
 774     // ex: movt r1, :upper16:_undef [arm mode]
 775     *kind = arm_movt;
 776     funcRel = false;
 777     top = true;
 778     thumbReloc = false;
 779     break;
 780   case ((ARM_RELOC_SECTDIFF       | rScattered | rLength4) << 16 |
 781          ARM_RELOC_PAIR           | rScattered | rLength4):
 782   case ((ARM_RELOC_LOCAL_SECTDIFF | rScattered | rLength4) << 16 |
 783          ARM_RELOC_PAIR           | rScattered | rLength4):
 784     // ex: .long _foo - .
 785     pointerDiff = true;
 786     break;
 787   default:
 788     return llvm::make_error<GenericError>("unsupported arm relocation pair");
 789   }
 790   const uint8_t *fixupContent = &inAtom->rawContent()[offsetInAtom];
 791   uint32_t instruction = *(const ulittle32_t *)fixupContent;
 792   uint32_t value;
 793   uint32_t fromAddress;
 794   uint32_t toAddress;
 795   uint16_t instruction16;
 796   uint16_t other16;
 797   const lld::Atom *fromTarget;
 798   Reference::Addend offsetInTo;
 799   Reference::Addend offsetInFrom;
 800   if (pointerDiff) {
 801     toAddress = reloc1.value;
 802     fromAddress = reloc2.value;
 803     if (auto ec = atomFromAddr(0, toAddress, target, &offsetInTo))
 804       return ec;
 805     if (auto ec = atomFromAddr(0, fromAddress, &fromTarget, &offsetInFrom))
 806       return ec;
 807     if (scatterable && (fromTarget != inAtom))
 808       return llvm::make_error<GenericError>(
 809           "SECTDIFF relocation where subtrahend label is not in atom");
 810     *kind = delta32;
 811     value = clearThumbBit(instruction, *target);
 812     *addend = (int32_t)(value - (toAddress - fixupAddress));
 813   } else if (funcRel) {
 814     toAddress = reloc1.value;
 815     fromAddress = reloc2.value;
 816     if (auto ec = atomFromAddr(0, toAddress, target, &offsetInTo))
 817       return ec;
 818     if (auto ec = atomFromAddr(0, fromAddress, &fromTarget, &offsetInFrom))
 819       return ec;
 820     if (fromTarget != inAtom)
 821       return llvm::make_error<GenericError>("ARM_RELOC_HALF_SECTDIFF relocation"
 822                                      " where subtrahend label is not in atom");
 823     other16 = (reloc2.offset & 0xFFFF);
 824     if (thumbReloc) {
 825       if (top) {
 826         if (!isThumbMovt(instruction))
 827           return llvm::make_error<GenericError>("expected movt instruction");
 828       }
 829       else {
 830         if (!isThumbMovw(instruction))
 831           return llvm::make_error<GenericError>("expected movw instruction");
 832       }
 833       instruction16 = getWordFromThumbMov(instruction);
 834     }
 835     else {
 836       if (top) {
 837         if (!isArmMovt(instruction))
 838           return llvm::make_error<GenericError>("expected movt instruction");
 839       }
 840       else {
 841         if (!isArmMovw(instruction))
 842           return llvm::make_error<GenericError>("expected movw instruction");
 843       }
 844       instruction16 = getWordFromArmMov(instruction);
 845     }
 846     if (top)
 847       value = (instruction16 << 16) | other16;
 848     else
 849       value = (other16 << 16) | instruction16;
 850     value = clearThumbBit(value, *target);
 851     int64_t ta = (int64_t) value - (toAddress - fromAddress);
 852     *addend = ta - offsetInFrom;
 853     return llvm::Error::success();
 854   } else {
 855     uint32_t sectIndex;
 856     if (thumbReloc) {
 857       if (top) {
 858         if (!isThumbMovt(instruction))
 859           return llvm::make_error<GenericError>("expected movt instruction");
 860       }
 861       else {
 862         if (!isThumbMovw(instruction))
 863           return llvm::make_error<GenericError>("expected movw instruction");
 864       }
 865       instruction16 = getWordFromThumbMov(instruction);
 866     }
 867     else {
 868       if (top) {
 869         if (!isArmMovt(instruction))
 870           return llvm::make_error<GenericError>("expected movt instruction");
 871       }
 872       else {
 873         if (!isArmMovw(instruction))
 874           return llvm::make_error<GenericError>("expected movw instruction");
 875       }
 876       instruction16 = getWordFromArmMov(instruction);
 877     }
 878     other16 = (reloc2.offset & 0xFFFF);
 879     if (top)
 880       value = (instruction16 << 16) | other16;
 881     else
 882       value = (other16 << 16) | instruction16;
 883     if (reloc1.isExtern) {
 884       if (auto ec = atomFromSymbolIndex(reloc1.symbol, target))
 885         return ec;
 886       *addend = value;
 887     } else {
 888       if (reloc1.scattered) {
 889         toAddress = reloc1.value;
 890         sectIndex = 0;
 891       } else {
 892         toAddress = value;
 893         sectIndex = reloc1.symbol;
 894       }
 895       if (auto ec = atomFromAddr(sectIndex, toAddress, target, &offsetInTo))
 896         return ec;
 897       *addend = value - toAddress;
 898     }
 899   }
 900
 901   return llvm::Error::success();
 902 }
 903
 904 void ArchHandler_arm::applyFixupFinal(const Reference &ref, uint8_t *loc,
 905                                       uint64_t fixupAddress,
 906                                       uint64_t targetAddress,
 907                                       uint64_t inAtomAddress,
 908                                       bool &thumbMode, bool targetIsThumb) {
 909   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
 910     return;
 911   assert(ref.kindArch() == Reference::KindArch::ARM);
 912   ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
 913   int32_t displacement;
 914   uint16_t value16;
 915   uint32_t value32;
 916   switch (static_cast<ArmKind>(ref.kindValue())) {
 917   case modeThumbCode:
 918     thumbMode = true;
 919     break;
 920   case modeArmCode:
 921     thumbMode = false;
 922     break;
 923   case modeData:
 924     break;
 925   case thumb_b22:
 926   case thumb_bl22:
 927     assert(thumbMode);
 928     displacement = (targetAddress - (fixupAddress + 4)) + ref.addend();
 929     value32 = setDisplacementInThumbBranch(*loc32, fixupAddress,
 930                                            displacement, targetIsThumb);
 931     *loc32 = value32;
 932     break;
 933   case thumb_movw:
 934     assert(thumbMode);
 935     value16 = (targetAddress + ref.addend()) & 0xFFFF;
 936     if (targetIsThumb)
 937       value16 |= 1;
 938     *loc32 = setWordFromThumbMov(*loc32, value16);
 939     break;
 940   case thumb_movt:
 941     assert(thumbMode);
 942     value16 = (targetAddress + ref.addend()) >> 16;
 943     *loc32 = setWordFromThumbMov(*loc32, value16);
 944     break;
 945   case thumb_movw_funcRel:
 946     assert(thumbMode);
 947     value16 = (targetAddress - inAtomAddress + ref.addend()) & 0xFFFF;
 948     if (targetIsThumb)
 949       value16 |= 1;
 950     *loc32 = setWordFromThumbMov(*loc32, value16);
 951     break;
 952   case thumb_movt_funcRel:
 953     assert(thumbMode);
 954     value16 = (targetAddress - inAtomAddress + ref.addend()) >> 16;
 955     *loc32 = setWordFromThumbMov(*loc32, value16);
 956     break;
 957   case arm_b24:
 958   case arm_bl24:
 959    assert(!thumbMode);
 960     displacement = (targetAddress - (fixupAddress + 8)) + ref.addend();
 961     value32 = setDisplacementInArmBranch(*loc32, displacement, targetIsThumb);
 962     *loc32 = value32;
 963     break;
 964   case arm_movw:
 965     assert(!thumbMode);
 966     value16 = (targetAddress + ref.addend()) & 0xFFFF;
 967     if (targetIsThumb)
 968       value16 |= 1;
 969     *loc32 = setWordFromArmMov(*loc32, value16);
 970     break;
 971   case arm_movt:
 972     assert(!thumbMode);
 973     value16 = (targetAddress + ref.addend()) >> 16;
 974     *loc32 = setWordFromArmMov(*loc32, value16);
 975     break;
 976   case arm_movw_funcRel:
 977     assert(!thumbMode);
 978     value16 = (targetAddress - inAtomAddress + ref.addend()) & 0xFFFF;
 979     if (targetIsThumb)
 980       value16 |= 1;
 981     *loc32 = setWordFromArmMov(*loc32, value16);
 982     break;
 983   case arm_movt_funcRel:
 984     assert(!thumbMode);
 985     value16 = (targetAddress - inAtomAddress + ref.addend()) >> 16;
 986     *loc32 = setWordFromArmMov(*loc32, value16);
 987     break;
 988   case pointer32:
 989     if (targetIsThumb)
 990       *loc32 = targetAddress + ref.addend() + 1;
 991     else
 992       *loc32 = targetAddress + ref.addend();
 993     break;
 994   case delta32:
 995     if (targetIsThumb)
 996       *loc32 = targetAddress - fixupAddress + ref.addend() + 1;
 997     else
 998       *loc32 = targetAddress - fixupAddress + ref.addend();
 999     break;
1000   case lazyPointer:
1001     // do nothing
1002     break;
1003   case lazyImmediateLocation:
1004     *loc32 = ref.addend();
1005     break;
1006   case invalid:
1007     llvm_unreachable("invalid ARM Reference Kind");
1008     break;
1009   }
1010 }
1011
1012 void ArchHandler_arm::generateAtomContent(const DefinedAtom &atom,
1013                                           bool relocatable,
1014                                           FindAddressForAtom findAddress,
1015                                           FindAddressForAtom findSectionAddress,
1016                                           uint64_t imageBaseAddress,
1017                             llvm::MutableArrayRef<uint8_t> atomContentBuffer) {
1018   // Copy raw bytes.
1019   std::copy(atom.rawContent().begin(), atom.rawContent().end(),
1020             atomContentBuffer.begin());
1021   // Apply fix-ups.
1022   bool thumbMode = false;
1023   for (const Reference *ref : atom) {
1024     uint32_t offset = ref->offsetInAtom();
1025     const Atom *target = ref->target();
1026     uint64_t targetAddress = 0;
1027     bool targetIsThumb = false;
1028     if (const DefinedAtom *defTarg = dyn_cast<DefinedAtom>(target)) {
1029       targetAddress = findAddress(*target);
1030       targetIsThumb = isThumbFunction(*defTarg);
1031     }
1032     uint64_t atomAddress = findAddress(atom);
1033     uint64_t fixupAddress = atomAddress + offset;
1034     if (relocatable) {
1035       applyFixupRelocatable(*ref, &atomContentBuffer[offset], fixupAddress,
1036                             targetAddress, atomAddress, thumbMode,
1037                             targetIsThumb);
1038     } else {
1039       applyFixupFinal(*ref, &atomContentBuffer[offset], fixupAddress,
1040                       targetAddress, atomAddress, thumbMode, targetIsThumb);
1041     }
1042   }
1043 }
1044
1045 bool ArchHandler_arm::useExternalRelocationTo(const Atom &target) {
1046   // Undefined symbols are referenced via external relocations.
1047   if (isa<UndefinedAtom>(&target))
1048     return true;
1049   if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(&target)) {
1050      switch (defAtom->merge()) {
1051      case DefinedAtom::mergeAsTentative:
1052        // Tentative definitions are referenced via external relocations.
1053        return true;
1054      case DefinedAtom::mergeAsWeak:
1055      case DefinedAtom::mergeAsWeakAndAddressUsed:
1056        // Global weak-defs are referenced via external relocations.
1057        return (defAtom->scope() == DefinedAtom::scopeGlobal);
1058      default:
1059        break;
1060     }
1061   }
1062   // Everything else is reference via an internal relocation.
1063   return false;
1064 }
1065
1066 void ArchHandler_arm::applyFixupRelocatable(const Reference &ref, uint8_t *loc,
1067                                             uint64_t fixupAddress,
1068                                             uint64_t targetAddress,
1069                                             uint64_t inAtomAddress,
1070                                             bool &thumbMode,
1071                                             bool targetIsThumb) {
1072   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
1073     return;
1074   assert(ref.kindArch() == Reference::KindArch::ARM);
1075   bool useExternalReloc = useExternalRelocationTo(*ref.target());
1076   ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
1077   int32_t displacement;
1078   uint16_t value16;
1079   uint32_t value32;
1080   bool targetIsUndef = isa<UndefinedAtom>(ref.target());
1081   switch (static_cast<ArmKind>(ref.kindValue())) {
1082   case modeThumbCode:
1083     thumbMode = true;
1084     break;
1085   case modeArmCode:
1086     thumbMode = false;
1087     break;
1088   case modeData:
1089     break;
1090   case thumb_b22:
1091   case thumb_bl22:
1092     assert(thumbMode);
1093     if (useExternalReloc)
1094       displacement = (ref.addend() - (fixupAddress + 4));
1095     else
1096       displacement = (targetAddress - (fixupAddress + 4)) + ref.addend();
1097     value32 = setDisplacementInThumbBranch(*loc32, fixupAddress,
1098                                            displacement,
1099                                            targetIsUndef || targetIsThumb);
1100     *loc32 = value32;
1101     break;
1102   case thumb_movw:
1103     assert(thumbMode);
1104     if (useExternalReloc)
1105       value16 = ref.addend() & 0xFFFF;
1106     else
1107       value16 = (targetAddress + ref.addend()) & 0xFFFF;
1108     *loc32 = setWordFromThumbMov(*loc32, value16);
1109     break;
1110   case thumb_movt:
1111     assert(thumbMode);
1112     if (useExternalReloc)
1113       value16 = ref.addend() >> 16;
1114     else
1115       value16 = (targetAddress + ref.addend()) >> 16;
1116     *loc32 = setWordFromThumbMov(*loc32, value16);
1117     break;
1118   case thumb_movw_funcRel:
1119     assert(thumbMode);
1120     value16 = (targetAddress - inAtomAddress + ref.addend()) & 0xFFFF;
1121     *loc32 = setWordFromThumbMov(*loc32, value16);
1122     break;
1123   case thumb_movt_funcRel:
1124     assert(thumbMode);
1125     value16 = (targetAddress - inAtomAddress + ref.addend()) >> 16;
1126     *loc32 = setWordFromThumbMov(*loc32, value16);
1127     break;
1128   case arm_b24:
1129   case arm_bl24:
1130     assert(!thumbMode);
1131     if (useExternalReloc)
1132       displacement = (ref.addend() - (fixupAddress + 8));
1133     else
1134       displacement = (targetAddress - (fixupAddress + 8)) + ref.addend();
1135     value32 = setDisplacementInArmBranch(*loc32, displacement,
1136                                          targetIsThumb);
1137     *loc32 = value32;
1138     break;
1139   case arm_movw:
1140     assert(!thumbMode);
1141     if (useExternalReloc)
1142       value16 = ref.addend() & 0xFFFF;
1143     else
1144       value16 = (targetAddress + ref.addend()) & 0xFFFF;
1145     *loc32 = setWordFromArmMov(*loc32, value16);
1146     break;
1147   case arm_movt:
1148     assert(!thumbMode);
1149     if (useExternalReloc)
1150       value16 = ref.addend() >> 16;
1151     else
1152       value16 = (targetAddress + ref.addend()) >> 16;
1153     *loc32 = setWordFromArmMov(*loc32, value16);
1154     break;
1155   case arm_movw_funcRel:
1156     assert(!thumbMode);
1157     value16 = (targetAddress - inAtomAddress + ref.addend()) & 0xFFFF;
1158     *loc32 = setWordFromArmMov(*loc32, value16);
1159     break;
1160   case arm_movt_funcRel:
1161     assert(!thumbMode);
1162     value16 = (targetAddress - inAtomAddress + ref.addend()) >> 16;
1163     *loc32 = setWordFromArmMov(*loc32, value16);
1164     break;
1165   case pointer32:
1166     *loc32 = targetAddress + ref.addend();
1167     break;
1168   case delta32:
1169     *loc32 = targetAddress - fixupAddress + ref.addend();
1170     break;
1171   case lazyPointer:
1172   case lazyImmediateLocation:
1173     // do nothing
1174     break;
1175   case invalid:
1176     llvm_unreachable("invalid ARM Reference Kind");
1177     break;
1178   }
1179 }
1180
1181 void ArchHandler_arm::appendSectionRelocations(
1182                                    const DefinedAtom &atom,
1183                                    uint64_t atomSectionOffset,
1184                                    const Reference &ref,
1185                                    FindSymbolIndexForAtom symbolIndexForAtom,
1186                                    FindSectionIndexForAtom sectionIndexForAtom,
1187                                    FindAddressForAtom addressForAtom,
1188                                    normalized::Relocations &relocs) {
1189   if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
1190     return;
1191   assert(ref.kindArch() == Reference::KindArch::ARM);
1192   uint32_t sectionOffset = atomSectionOffset + ref.offsetInAtom();
1193   bool useExternalReloc = useExternalRelocationTo(*ref.target());
1194   uint32_t targetAtomAddress;
1195   uint32_t fromAtomAddress;
1196   uint16_t other16;
1197   switch (static_cast<ArmKind>(ref.kindValue())) {
1198   case modeThumbCode:
1199   case modeArmCode:
1200   case modeData:
1201     // Do nothing.
1202     break;
1203   case thumb_b22:
1204   case thumb_bl22:
1205     if (useExternalReloc) {
1206       appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
1207                   ARM_THUMB_RELOC_BR22 | rExtern    | rPcRel | rLength4);
1208     } else {
1209       if (ref.addend() != 0)
1210         appendReloc(relocs, sectionOffset, 0, addressForAtom(*ref.target()),
1211                   ARM_THUMB_RELOC_BR22 | rScattered | rPcRel | rLength4);
1212       else
1213         appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
1214                   ARM_THUMB_RELOC_BR22 |              rPcRel | rLength4);
1215     }
1216     break;
1217   case thumb_movw:
1218     if (useExternalReloc) {
1219       other16 = ref.addend() >> 16;
1220       appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
1221                   ARM_RELOC_HALF | rExtern    | rLenThmbLo);
1222       appendReloc(relocs, other16, 0, 0,
1223                   ARM_RELOC_PAIR              | rLenThmbLo);
1224     } else {
1225       targetAtomAddress = addressForAtom(*ref.target());
1226       if (ref.addend() != 0) {
1227         other16 = (targetAtomAddress + ref.addend()) >> 16;
1228         appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
1229                   ARM_RELOC_HALF | rScattered | rLenThmbLo);
1230         appendReloc(relocs, other16, 0, 0,
1231                   ARM_RELOC_PAIR              | rLenThmbLo);
1232       } else {
1233         other16 = (targetAtomAddress + ref.addend()) >> 16;
1234         appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
1235                   ARM_RELOC_HALF              | rLenThmbLo);
1236         appendReloc(relocs, other16, 0, 0,
1237                   ARM_RELOC_PAIR              | rLenThmbLo);
1238       }
1239     }
1240     break;
1241   case thumb_movt:
1242     if (useExternalReloc) {
1243       other16 = ref.addend() & 0xFFFF;
1244       appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
1245                   ARM_RELOC_HALF | rExtern    | rLenThmbHi);
1246       appendReloc(relocs, other16, 0, 0,
1247                   ARM_RELOC_PAIR              | rLenThmbHi);
1248     } else {
1249       targetAtomAddress = addressForAtom(*ref.target());
1250       if (ref.addend() != 0) {
1251         other16 = (targetAtomAddress + ref.addend()) & 0xFFFF;
1252         appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
1253                     ARM_RELOC_HALF | rScattered | rLenThmbHi);
1254         appendReloc(relocs, other16, 0, 0,
1255                     ARM_RELOC_PAIR              | rLenThmbHi);
1256       } else {
1257         other16 = (targetAtomAddress + ref.addend()) & 0xFFFF;
1258         appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
1259                     ARM_RELOC_HALF              | rLenThmbHi);
1260         appendReloc(relocs, other16, 0, 0,
1261                     ARM_RELOC_PAIR              | rLenThmbHi);
1262       }
1263     }
1264     break;
1265   case thumb_movw_funcRel:
1266     fromAtomAddress = addressForAtom(atom);
1267     targetAtomAddress = addressForAtom(*ref.target());
1268     other16 = (targetAtomAddress - fromAtomAddress + ref.addend()) >> 16;
1269     appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
1270                 ARM_RELOC_HALF_SECTDIFF | rScattered | rLenThmbLo);
1271     appendReloc(relocs, other16, 0, fromAtomAddress,
1272                 ARM_RELOC_PAIR          | rScattered | rLenThmbLo);
1273     break;
1274   case thumb_movt_funcRel:
1275     fromAtomAddress = addressForAtom(atom);
1276     targetAtomAddress = addressForAtom(*ref.target());
1277     other16 = (targetAtomAddress - fromAtomAddress + ref.addend()) & 0xFFFF;
1278     appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
1279                 ARM_RELOC_HALF_SECTDIFF | rScattered | rLenThmbHi);
1280     appendReloc(relocs, other16, 0, fromAtomAddress,
1281                 ARM_RELOC_PAIR          | rScattered | rLenThmbHi);
1282     break;
1283   case arm_b24:
1284   case arm_bl24:
1285     if (useExternalReloc) {
1286       appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
1287                   ARM_RELOC_BR24 | rExtern    | rPcRel | rLength4);
1288     } else {
1289       if (ref.addend() != 0)
1290         appendReloc(relocs, sectionOffset, 0, addressForAtom(*ref.target()),
1291                   ARM_RELOC_BR24 | rScattered | rPcRel | rLength4);
1292       else
1293         appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
1294                   ARM_RELOC_BR24 |              rPcRel | rLength4);
1295     }
1296     break;
1297   case arm_movw:
1298     if (useExternalReloc) {
1299       other16 = ref.addend() >> 16;
1300       appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
1301                   ARM_RELOC_HALF | rExtern    | rLenArmLo);
1302       appendReloc(relocs, other16, 0, 0,
1303                   ARM_RELOC_PAIR              | rLenArmLo);
1304     } else {
1305       targetAtomAddress = addressForAtom(*ref.target());
1306       if (ref.addend() != 0) {
1307         other16 = (targetAtomAddress + ref.addend()) >> 16;
1308         appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
1309                   ARM_RELOC_HALF | rScattered | rLenArmLo);
1310         appendReloc(relocs, other16, 0, 0,
1311                   ARM_RELOC_PAIR              | rLenArmLo);
1312       } else {
1313         other16 = (targetAtomAddress + ref.addend()) >> 16;
1314         appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
1315                   ARM_RELOC_HALF              | rLenArmLo);
1316         appendReloc(relocs, other16, 0, 0,
1317                   ARM_RELOC_PAIR              | rLenArmLo);
1318       }
1319     }
1320     break;
1321   case arm_movt:
1322     if (useExternalReloc) {
1323       other16 = ref.addend() & 0xFFFF;
1324       appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
1325                   ARM_RELOC_HALF | rExtern    | rLenArmHi);
1326       appendReloc(relocs, other16, 0, 0,
1327                   ARM_RELOC_PAIR              | rLenArmHi);
1328     } else {
1329       targetAtomAddress = addressForAtom(*ref.target());
1330       if (ref.addend() != 0) {
1331         other16 = (targetAtomAddress + ref.addend()) & 0xFFFF;
1332         appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
1333                   ARM_RELOC_HALF | rScattered | rLenArmHi);
1334         appendReloc(relocs, other16, 0, 0,
1335                   ARM_RELOC_PAIR              | rLenArmHi);
1336       } else {
1337         other16 = (targetAtomAddress + ref.addend()) & 0xFFFF;
1338         appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
1339                   ARM_RELOC_HALF              | rLenArmHi);
1340         appendReloc(relocs, other16, 0, 0,
1341                   ARM_RELOC_PAIR              | rLenArmHi);
1342       }
1343     }
1344     break;
1345   case arm_movw_funcRel:
1346     fromAtomAddress = addressForAtom(atom);
1347     targetAtomAddress = addressForAtom(*ref.target());
1348     other16 = (targetAtomAddress - fromAtomAddress + ref.addend()) >> 16;
1349     appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
1350                 ARM_RELOC_HALF_SECTDIFF | rScattered | rLenArmLo);
1351     appendReloc(relocs, other16, 0, fromAtomAddress,
1352                 ARM_RELOC_PAIR          | rScattered | rLenArmLo);
1353     break;
1354   case arm_movt_funcRel:
1355     fromAtomAddress = addressForAtom(atom);
1356     targetAtomAddress = addressForAtom(*ref.target());
1357     other16 = (targetAtomAddress - fromAtomAddress + ref.addend()) & 0xFFFF;
1358     appendReloc(relocs, sectionOffset, 0, targetAtomAddress,
1359                 ARM_RELOC_HALF_SECTDIFF | rScattered | rLenArmHi);
1360     appendReloc(relocs, other16, 0, fromAtomAddress,
1361                 ARM_RELOC_PAIR          | rScattered | rLenArmHi);
1362     break;
1363   case pointer32:
1364     if (useExternalReloc) {
1365       appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()),  0,
1366                 ARM_RELOC_VANILLA |    rExtern     |  rLength4);
1367     }
1368     else {
1369       if (ref.addend() != 0)
1370         appendReloc(relocs, sectionOffset, 0, addressForAtom(*ref.target()),
1371                 ARM_RELOC_VANILLA |    rScattered  |  rLength4);
1372       else
1373         appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()),0,
1374                 ARM_RELOC_VANILLA |                   rLength4);
1375     }
1376     break;
1377   case delta32:
1378     appendReloc(relocs, sectionOffset, 0, addressForAtom(*ref.target()),
1379               ARM_RELOC_SECTDIFF  |  rScattered    | rLength4);
1380     appendReloc(relocs, sectionOffset, 0, addressForAtom(atom) +
1381                                                            ref.offsetInAtom(),
1382               ARM_RELOC_PAIR      |  rScattered    | rLength4);
1383     break;
1384   case lazyPointer:
1385   case lazyImmediateLocation:
1386     // do nothing
1387     break;
1388   case invalid:
1389     llvm_unreachable("invalid ARM Reference Kind");
1390     break;
1391   }
1392 }
1393
1394 void ArchHandler_arm::addAdditionalReferences(MachODefinedAtom &atom) {
1395   if (atom.isThumb()) {
1396     atom.addReference(Reference::KindNamespace::mach_o,
1397                       Reference::KindArch::ARM, modeThumbCode, 0, &atom, 0);
1398   }
1399 }
1400
1401 bool ArchHandler_arm::isThumbFunction(const DefinedAtom &atom) {
1402   for (const Reference *ref : atom) {
1403     if (ref->offsetInAtom() != 0)
1404       return false;
1405     if (ref->kindNamespace() != Reference::KindNamespace::mach_o)
1406       continue;
1407     assert(ref->kindArch() == Reference::KindArch::ARM);
1408     if (ref->kindValue() == modeThumbCode)
1409       return true;
1410   }
1411   return false;
1412 }
1413
1414 class Thumb2ToArmShimAtom : public SimpleDefinedAtom {
1415 public:
1416   Thumb2ToArmShimAtom(MachOFile &file, StringRef targetName,
1417                       const DefinedAtom &target)
1418       : SimpleDefinedAtom(file) {
1419     addReference(Reference::KindNamespace::mach_o, Reference::KindArch::ARM,
1420                  ArchHandler_arm::modeThumbCode, 0, this, 0);
1421     addReference(Reference::KindNamespace::mach_o, Reference::KindArch::ARM,
1422                  ArchHandler_arm::delta32, 8, &target, 0);
1423     std::string name = std::string(targetName) + "$shim";
1424     StringRef tmp(name);
1425     _name = tmp.copy(file.allocator());
1426   }
1427
1428   ~Thumb2ToArmShimAtom() override = default;
1429
1430   StringRef name() const override {
1431     return _name;
1432   }
1433
1434   ContentType contentType() const override {
1435     return DefinedAtom::typeCode;
1436   }
1437
1438   Alignment alignment() const override { return 4; }
1439
1440   uint64_t size() const override {
1441     return 12;
1442   }
1443
1444   ContentPermissions permissions() const override {
1445     return DefinedAtom::permR_X;
1446   }
1447
1448   ArrayRef<uint8_t> rawContent() const override {
1449     static const uint8_t bytes[] =
1450     { 0xDF, 0xF8, 0x04, 0xC0,       //  ldr ip, pc + 4
1451       0xFF, 0x44,                   //  add ip, pc, ip
1452       0x60, 0x47,                   //  ldr pc, [ip]
1453       0x00, 0x00, 0x00, 0x00 };     //  .long target - this
1454     assert(sizeof(bytes) == size());
1455     return llvm::makeArrayRef(bytes, sizeof(bytes));
1456   }
1457 private:
1458   StringRef _name;
1459 };
1460
1461 class ArmToThumbShimAtom : public SimpleDefinedAtom {
1462 public:
1463   ArmToThumbShimAtom(MachOFile &file, StringRef targetName,
1464                      const DefinedAtom &target)
1465       : SimpleDefinedAtom(file) {
1466     addReference(Reference::KindNamespace::mach_o, Reference::KindArch::ARM,
1467                  ArchHandler_arm::delta32, 12, &target, 0);
1468     std::string name = std::string(targetName) + "$shim";
1469     StringRef tmp(name);
1470     _name = tmp.copy(file.allocator());
1471   }
1472
1473   ~ArmToThumbShimAtom() override = default;
1474
1475   StringRef name() const override {
1476     return _name;
1477   }
1478
1479   ContentType contentType() const override {
1480     return DefinedAtom::typeCode;
1481   }
1482
1483   Alignment alignment() const override { return 4; }
1484
1485   uint64_t size() const override {
1486     return 16;
1487   }
1488
1489   ContentPermissions permissions() const override {
1490     return DefinedAtom::permR_X;
1491   }
1492
1493   ArrayRef<uint8_t> rawContent() const override {
1494     static const uint8_t bytes[] =
1495     { 0x04, 0xC0, 0x9F, 0xE5,       //  ldr ip, pc + 4
1496       0x0C, 0xC0, 0x8F, 0xE0,       //  add ip, pc, ip
1497       0x1C, 0xFF, 0x2F, 0xE1,       //  ldr pc, [ip]
1498       0x00, 0x00, 0x00, 0x00 };     //  .long target - this
1499     assert(sizeof(bytes) == size());
1500     return llvm::makeArrayRef(bytes, sizeof(bytes));
1501   }
1502 private:
1503   StringRef _name;
1504 };
1505
1506 const DefinedAtom *ArchHandler_arm::createShim(MachOFile &file,
1507                                                bool thumbToArm,
1508                                                const DefinedAtom &target) {
1509   bool isStub = (target.contentType() == DefinedAtom::typeStub);
1510   StringRef targetName = isStub ? stubName(target) : target.name();
1511   if (thumbToArm)
1512     return new (file.allocator()) Thumb2ToArmShimAtom(file, targetName, target);
1513   else
1514     return new (file.allocator()) ArmToThumbShimAtom(file, targetName, target);
1515 }
1516
1517 std::unique_ptr<mach_o::ArchHandler> ArchHandler::create_arm() {
1518   return std::unique_ptr<mach_o::ArchHandler>(new ArchHandler_arm());
1519 }
1520
1521 } // namespace mach_o
1522 } // namespace lld