lib/Target/AArch64/MCTargetDesc/AArch64MachObjectWriter.cpp

   1 //===-- AArch64MachObjectWriter.cpp - ARM Mach Object Writer --------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   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 "MCTargetDesc/AArch64FixupKinds.h"
  11 #include "MCTargetDesc/AArch64MCTargetDesc.h"
  12 #include "llvm/ADT/Twine.h"
  13 #include "llvm/MC/MCAsmInfo.h"
  14 #include "llvm/MC/MCAsmLayout.h"
  15 #include "llvm/MC/MCAssembler.h"
  16 #include "llvm/MC/MCContext.h"
  17 #include "llvm/MC/MCExpr.h"
  18 #include "llvm/MC/MCFixup.h"
  19 #include "llvm/MC/MCMachObjectWriter.h"
  20 #include "llvm/MC/MCSectionMachO.h"
  21 #include "llvm/MC/MCValue.h"
  22 #include "llvm/Support/ErrorHandling.h"
  23 #include "llvm/Support/MachO.h"
  24 using namespace llvm;
  25
  26 namespace {
  27 class AArch64MachObjectWriter : public MCMachObjectTargetWriter {
  28   bool getAArch64FixupKindMachOInfo(const MCFixup &Fixup, unsigned &RelocType,
  29                                   const MCSymbolRefExpr *Sym,
  30                                   unsigned &Log2Size, const MCAssembler &Asm);
  31
  32 public:
  33   AArch64MachObjectWriter(uint32_t CPUType, uint32_t CPUSubtype)
  34       : MCMachObjectTargetWriter(true /* is64Bit */, CPUType, CPUSubtype,
  35                                  /*UseAggressiveSymbolFolding=*/true) {}
  36
  37   void RecordRelocation(MachObjectWriter *Writer, MCAssembler &Asm,
  38                         const MCAsmLayout &Layout, const MCFragment *Fragment,
  39                         const MCFixup &Fixup, MCValue Target,
  40                         uint64_t &FixedValue) override;
  41 };
  42 }
  43
  44 bool AArch64MachObjectWriter::getAArch64FixupKindMachOInfo(
  45     const MCFixup &Fixup, unsigned &RelocType, const MCSymbolRefExpr *Sym,
  46     unsigned &Log2Size, const MCAssembler &Asm) {
  47   RelocType = unsigned(MachO::ARM64_RELOC_UNSIGNED);
  48   Log2Size = ~0U;
  49
  50   switch ((unsigned)Fixup.getKind()) {
  51   default:
  52     return false;
  53
  54   case FK_Data_1:
  55     Log2Size = llvm::Log2_32(1);
  56     return true;
  57   case FK_Data_2:
  58     Log2Size = llvm::Log2_32(2);
  59     return true;
  60   case FK_Data_4:
  61     Log2Size = llvm::Log2_32(4);
  62     if (Sym->getKind() == MCSymbolRefExpr::VK_GOT)
  63       RelocType = unsigned(MachO::ARM64_RELOC_POINTER_TO_GOT);
  64     return true;
  65   case FK_Data_8:
  66     Log2Size = llvm::Log2_32(8);
  67     if (Sym->getKind() == MCSymbolRefExpr::VK_GOT)
  68       RelocType = unsigned(MachO::ARM64_RELOC_POINTER_TO_GOT);
  69     return true;
  70   case AArch64::fixup_aarch64_add_imm12:
  71   case AArch64::fixup_aarch64_ldst_imm12_scale1:
  72   case AArch64::fixup_aarch64_ldst_imm12_scale2:
  73   case AArch64::fixup_aarch64_ldst_imm12_scale4:
  74   case AArch64::fixup_aarch64_ldst_imm12_scale8:
  75   case AArch64::fixup_aarch64_ldst_imm12_scale16:
  76     Log2Size = llvm::Log2_32(4);
  77     switch (Sym->getKind()) {
  78     default:
  79       llvm_unreachable("Unexpected symbol reference variant kind!");
  80     case MCSymbolRefExpr::VK_PAGEOFF:
  81       RelocType = unsigned(MachO::ARM64_RELOC_PAGEOFF12);
  82       return true;
  83     case MCSymbolRefExpr::VK_GOTPAGEOFF:
  84       RelocType = unsigned(MachO::ARM64_RELOC_GOT_LOAD_PAGEOFF12);
  85       return true;
  86     case MCSymbolRefExpr::VK_TLVPPAGEOFF:
  87       RelocType = unsigned(MachO::ARM64_RELOC_TLVP_LOAD_PAGEOFF12);
  88       return true;
  89     }
  90   case AArch64::fixup_aarch64_pcrel_adrp_imm21:
  91     Log2Size = llvm::Log2_32(4);
  92     // This encompasses the relocation for the whole 21-bit value.
  93     switch (Sym->getKind()) {
  94     default:
  95       Asm.getContext().FatalError(Fixup.getLoc(),
  96                                   "ADR/ADRP relocations must be GOT relative");
  97     case MCSymbolRefExpr::VK_PAGE:
  98       RelocType = unsigned(MachO::ARM64_RELOC_PAGE21);
  99       return true;
 100     case MCSymbolRefExpr::VK_GOTPAGE:
 101       RelocType = unsigned(MachO::ARM64_RELOC_GOT_LOAD_PAGE21);
 102       return true;
 103     case MCSymbolRefExpr::VK_TLVPPAGE:
 104       RelocType = unsigned(MachO::ARM64_RELOC_TLVP_LOAD_PAGE21);
 105       return true;
 106     }
 107     return true;
 108   case AArch64::fixup_aarch64_pcrel_branch26:
 109   case AArch64::fixup_aarch64_pcrel_call26:
 110     Log2Size = llvm::Log2_32(4);
 111     RelocType = unsigned(MachO::ARM64_RELOC_BRANCH26);
 112     return true;
 113   }
 114 }
 115
 116 static bool canUseLocalRelocation(const MCSectionMachO &Section,
 117                                   const MCSymbol &Symbol, unsigned Log2Size) {
 118   // Debug info sections can use local relocations.
 119   if (Section.hasAttribute(MachO::S_ATTR_DEBUG))
 120     return true;
 121
 122   // Otherwise, only pointer sized relocations are supported.
 123   if (Log2Size != 3)
 124     return false;
 125
 126   // But only if they don't point to a few forbidden sections.
 127   if (!Symbol.isInSection())
 128     return true;
 129   const MCSectionMachO &RefSec = cast<MCSectionMachO>(Symbol.getSection());
 130   if (RefSec.getType() == MachO::S_CSTRING_LITERALS)
 131     return false;
 132
 133   if (RefSec.getSegmentName() == "__DATA" &&
 134       RefSec.getSectionName() == "__cfstring")
 135     return false;
 136
 137   if (RefSec.getSegmentName() == "__DATA" &&
 138       RefSec.getSectionName() == "__objc_classrefs")
 139     return false;
 140
 141   return true;
 142 }
 143
 144 void AArch64MachObjectWriter::RecordRelocation(
 145     MachObjectWriter *Writer, MCAssembler &Asm, const MCAsmLayout &Layout,
 146     const MCFragment *Fragment, const MCFixup &Fixup, MCValue Target,
 147     uint64_t &FixedValue) {
 148   unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind());
 149
 150   // See <reloc.h>.
 151   uint32_t FixupOffset = Layout.getFragmentOffset(Fragment);
 152   unsigned Log2Size = 0;
 153   int64_t Value = 0;
 154   unsigned Index = 0;
 155   unsigned Type = 0;
 156   unsigned Kind = Fixup.getKind();
 157   const MCSymbol *RelSymbol = nullptr;
 158
 159   FixupOffset += Fixup.getOffset();
 160
 161   // AArch64 pcrel relocation addends do not include the section offset.
 162   if (IsPCRel)
 163     FixedValue += FixupOffset;
 164
 165   // ADRP fixups use relocations for the whole symbol value and only
 166   // put the addend in the instruction itself. Clear out any value the
 167   // generic code figured out from the sybmol definition.
 168   if (Kind == AArch64::fixup_aarch64_pcrel_adrp_imm21)
 169     FixedValue = 0;
 170
 171   // imm19 relocations are for conditional branches, which require
 172   // assembler local symbols. If we got here, that's not what we have,
 173   // so complain loudly.
 174   if (Kind == AArch64::fixup_aarch64_pcrel_branch19) {
 175     Asm.getContext().FatalError(Fixup.getLoc(),
 176                                 "conditional branch requires assembler-local"
 177                                 " label. '" +
 178                                     Target.getSymA()->getSymbol().getName() +
 179                                     "' is external.");
 180     return;
 181   }
 182
 183   // 14-bit branch relocations should only target internal labels, and so
 184   // should never get here.
 185   if (Kind == AArch64::fixup_aarch64_pcrel_branch14) {
 186     Asm.getContext().FatalError(Fixup.getLoc(),
 187                                 "Invalid relocation on conditional branch!");
 188     return;
 189   }
 190
 191   if (!getAArch64FixupKindMachOInfo(Fixup, Type, Target.getSymA(), Log2Size,
 192                                   Asm)) {
 193     Asm.getContext().FatalError(Fixup.getLoc(), "unknown AArch64 fixup kind!");
 194     return;
 195   }
 196
 197   Value = Target.getConstant();
 198
 199   if (Target.isAbsolute()) { // constant
 200     // FIXME: Should this always be extern?
 201     // SymbolNum of 0 indicates the absolute section.
 202     Type = MachO::ARM64_RELOC_UNSIGNED;
 203
 204     if (IsPCRel) {
 205       Asm.getContext().FatalError(Fixup.getLoc(),
 206                                   "PC relative absolute relocation!");
 207
 208       // FIXME: x86_64 sets the type to a branch reloc here. Should we do
 209       // something similar?
 210     }
 211   } else if (Target.getSymB()) { // A - B + constant
 212     const MCSymbol *A = &Target.getSymA()->getSymbol();
 213     const MCSymbolData &A_SD = Asm.getSymbolData(*A);
 214     const MCSymbol *A_Base = Asm.getAtom(&A_SD);
 215
 216     const MCSymbol *B = &Target.getSymB()->getSymbol();
 217     const MCSymbolData &B_SD = Asm.getSymbolData(*B);
 218     const MCSymbol *B_Base = Asm.getAtom(&B_SD);
 219
 220     // Check for "_foo@got - .", which comes through here as:
 221     // Ltmp0:
 222     //    ... _foo@got - Ltmp0
 223     if (Target.getSymA()->getKind() == MCSymbolRefExpr::VK_GOT &&
 224         Target.getSymB()->getKind() == MCSymbolRefExpr::VK_None &&
 225         Layout.getSymbolOffset(&B_SD) ==
 226             Layout.getFragmentOffset(Fragment) + Fixup.getOffset()) {
 227       // SymB is the PC, so use a PC-rel pointer-to-GOT relocation.
 228       Type = MachO::ARM64_RELOC_POINTER_TO_GOT;
 229       IsPCRel = 1;
 230       MachO::any_relocation_info MRE;
 231       MRE.r_word0 = FixupOffset;
 232       MRE.r_word1 = (IsPCRel << 24) | (Log2Size << 25) | (Type << 28);
 233       Writer->addRelocation(A_Base ? &A_Base->getData() : nullptr,
 234                             Fragment->getParent(), MRE);
 235       return;
 236     } else if (Target.getSymA()->getKind() != MCSymbolRefExpr::VK_None ||
 237                Target.getSymB()->getKind() != MCSymbolRefExpr::VK_None)
 238       // Otherwise, neither symbol can be modified.
 239       Asm.getContext().FatalError(Fixup.getLoc(),
 240                                   "unsupported relocation of modified symbol");
 241
 242     // We don't support PCrel relocations of differences.
 243     if (IsPCRel)
 244       Asm.getContext().FatalError(Fixup.getLoc(),
 245                                   "unsupported pc-relative relocation of "
 246                                   "difference");
 247
 248     // AArch64 always uses external relocations. If there is no symbol to use as
 249     // a base address (a local symbol with no preceding non-local symbol),
 250     // error out.
 251     //
 252     // FIXME: We should probably just synthesize an external symbol and use
 253     // that.
 254     if (!A_Base)
 255       Asm.getContext().FatalError(
 256           Fixup.getLoc(),
 257           "unsupported relocation of local symbol '" + A->getName() +
 258               "'. Must have non-local symbol earlier in section.");
 259     if (!B_Base)
 260       Asm.getContext().FatalError(
 261           Fixup.getLoc(),
 262           "unsupported relocation of local symbol '" + B->getName() +
 263               "'. Must have non-local symbol earlier in section.");
 264
 265     if (A_Base == B_Base && A_Base)
 266       Asm.getContext().FatalError(Fixup.getLoc(),
 267                                   "unsupported relocation with identical base");
 268
 269     Value +=
 270         (!A_SD.getFragment() ? 0 : Writer->getSymbolAddress(&A_SD, Layout)) -
 271         (!A_Base || !A_Base->getData().getFragment()
 272              ? 0
 273              : Writer->getSymbolAddress(&A_Base->getData(), Layout));
 274     Value -=
 275         (!B_SD.getFragment() ? 0 : Writer->getSymbolAddress(&B_SD, Layout)) -
 276         (!B_Base || !B_Base->getData().getFragment()
 277              ? 0
 278              : Writer->getSymbolAddress(&B_Base->getData(), Layout));
 279
 280     Type = MachO::ARM64_RELOC_UNSIGNED;
 281
 282     MachO::any_relocation_info MRE;
 283     MRE.r_word0 = FixupOffset;
 284     MRE.r_word1 = (IsPCRel << 24) | (Log2Size << 25) | (Type << 28);
 285     Writer->addRelocation(A_Base ? &A_Base->getData() : nullptr,
 286                           Fragment->getParent(), MRE);
 287
 288     RelSymbol = B_Base;
 289     Type = MachO::ARM64_RELOC_SUBTRACTOR;
 290   } else { // A + constant
 291     const MCSymbol *Symbol = &Target.getSymA()->getSymbol();
 292     const MCSectionMachO &Section = static_cast<const MCSectionMachO &>(
 293         Fragment->getParent()->getSection());
 294
 295     bool CanUseLocalRelocation =
 296         canUseLocalRelocation(Section, *Symbol, Log2Size);
 297     if (Symbol->isTemporary() && (Value || !CanUseLocalRelocation)) {
 298       const MCSection &Sec = Symbol->getSection();
 299       if (!Asm.getContext().getAsmInfo()->isSectionAtomizableBySymbols(Sec))
 300         Asm.addLocalUsedInReloc(*Symbol);
 301     }
 302
 303     const MCSymbolData &SD = Asm.getSymbolData(*Symbol);
 304     const MCSymbol *Base = Asm.getAtom(&SD);
 305
 306     // If the symbol is a variable and we weren't able to get a Base for it
 307     // (i.e., it's not in the symbol table associated with a section) resolve
 308     // the relocation based its expansion instead.
 309     if (Symbol->isVariable() && !Base) {
 310       // If the evaluation is an absolute value, just use that directly
 311       // to keep things easy.
 312       int64_t Res;
 313       if (SD.getSymbol().getVariableValue()->EvaluateAsAbsolute(
 314               Res, Layout, Writer->getSectionAddressMap())) {
 315         FixedValue = Res;
 316         return;
 317       }
 318
 319       // FIXME: Will the Target we already have ever have any data in it
 320       // we need to preserve and merge with the new Target? How about
 321       // the FixedValue?
 322       if (!Symbol->getVariableValue()->EvaluateAsRelocatable(Target, &Layout,
 323                                                              &Fixup))
 324         Asm.getContext().FatalError(Fixup.getLoc(),
 325                                     "unable to resolve variable '" +
 326                                         Symbol->getName() + "'");
 327       return RecordRelocation(Writer, Asm, Layout, Fragment, Fixup, Target,
 328                               FixedValue);
 329     }
 330
 331     // Relocations inside debug sections always use local relocations when
 332     // possible. This seems to be done because the debugger doesn't fully
 333     // understand relocation entries and expects to find values that
 334     // have already been fixed up.
 335     if (Symbol->isInSection()) {
 336       if (Section.hasAttribute(MachO::S_ATTR_DEBUG))
 337         Base = nullptr;
 338     }
 339
 340     // AArch64 uses external relocations as much as possible. For debug
 341     // sections, and for pointer-sized relocations (.quad), we allow section
 342     // relocations.  It's code sections that run into trouble.
 343     if (Base) {
 344       RelSymbol = Base;
 345
 346       // Add the local offset, if needed.
 347       if (&Base->getData() != &SD)
 348         Value += Layout.getSymbolOffset(&SD) -
 349                  Layout.getSymbolOffset(&Base->getData());
 350     } else if (Symbol->isInSection()) {
 351       if (!CanUseLocalRelocation)
 352         Asm.getContext().FatalError(
 353             Fixup.getLoc(),
 354             "unsupported relocation of local symbol '" + Symbol->getName() +
 355                 "'. Must have non-local symbol earlier in section.");
 356       // Adjust the relocation to be section-relative.
 357       // The index is the section ordinal (1-based).
 358       const MCSectionData &SymSD =
 359           Asm.getSectionData(SD.getSymbol().getSection());
 360       Index = SymSD.getOrdinal() + 1;
 361       Value += Writer->getSymbolAddress(&SD, Layout);
 362
 363       if (IsPCRel)
 364         Value -= Writer->getFragmentAddress(Fragment, Layout) +
 365                  Fixup.getOffset() + (1ULL << Log2Size);
 366     } else {
 367       // Resolve constant variables.
 368       if (SD.getSymbol().isVariable()) {
 369         int64_t Res;
 370         if (SD.getSymbol().getVariableValue()->EvaluateAsAbsolute(
 371                 Res, Layout, Writer->getSectionAddressMap())) {
 372           FixedValue = Res;
 373           return;
 374         }
 375       }
 376       Asm.getContext().FatalError(Fixup.getLoc(),
 377                                   "unsupported relocation of variable '" +
 378                                       Symbol->getName() + "'");
 379     }
 380   }
 381
 382   // If the relocation kind is Branch26, Page21, or Pageoff12, any addend
 383   // is represented via an Addend relocation, not encoded directly into
 384   // the instruction.
 385   if ((Type == MachO::ARM64_RELOC_BRANCH26 ||
 386        Type == MachO::ARM64_RELOC_PAGE21 ||
 387        Type == MachO::ARM64_RELOC_PAGEOFF12) &&
 388       Value) {
 389     assert((Value & 0xff000000) == 0 && "Added relocation out of range!");
 390
 391     MachO::any_relocation_info MRE;
 392     MRE.r_word0 = FixupOffset;
 393     MRE.r_word1 =
 394         (Index << 0) | (IsPCRel << 24) | (Log2Size << 25) | (Type << 28);
 395     Writer->addRelocation(RelSymbol ? &RelSymbol->getData() : nullptr,
 396                           Fragment->getParent(), MRE);
 397
 398     // Now set up the Addend relocation.
 399     Type = MachO::ARM64_RELOC_ADDEND;
 400     Index = Value;
 401     RelSymbol = nullptr;
 402     IsPCRel = 0;
 403     Log2Size = 2;
 404
 405     // Put zero into the instruction itself. The addend is in the relocation.
 406     Value = 0;
 407   }
 408
 409   // If there's any addend left to handle, encode it in the instruction.
 410   FixedValue = Value;
 411
 412   // struct relocation_info (8 bytes)
 413   MachO::any_relocation_info MRE;
 414   MRE.r_word0 = FixupOffset;
 415   MRE.r_word1 =
 416       (Index << 0) | (IsPCRel << 24) | (Log2Size << 25) | (Type << 28);
 417   Writer->addRelocation(RelSymbol ? &RelSymbol->getData() : nullptr,
 418                         Fragment->getParent(), MRE);
 419 }
 420
 421 MCObjectWriter *llvm::createAArch64MachObjectWriter(raw_pwrite_stream &OS,
 422                                                     uint32_t CPUType,
 423                                                     uint32_t CPUSubtype) {
 424   return createMachObjectWriter(
 425       new AArch64MachObjectWriter(CPUType, CPUSubtype), OS,
 426       /*IsLittleEndian=*/true);
 427 }