1 //===- X86_64.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 "InputFiles.h" 10 #include "Symbols.h" 11 #include "SyntheticSections.h" 12 #include "Target.h" 13 14 #include "lld/Common/ErrorHandler.h" 15 #include "mach-o/compact_unwind_encoding.h" 16 #include "llvm/BinaryFormat/MachO.h" 17 #include "llvm/Support/Endian.h" 18 19 using namespace llvm::MachO; 20 using namespace llvm::support::endian; 21 using namespace lld; 22 using namespace lld::macho; 23 24 namespace { 25 26 struct X86_64 : TargetInfo { 27 X86_64(); 28 29 int64_t getEmbeddedAddend(MemoryBufferRef, uint64_t offset, 30 const relocation_info) const override; 31 void relocateOne(uint8_t *loc, const Reloc &, uint64_t va, 32 uint64_t relocVA) const override; 33 34 void writeStub(uint8_t *buf, const Symbol &) const override; 35 void writeStubHelperHeader(uint8_t *buf) const override; 36 void writeStubHelperEntry(uint8_t *buf, const Symbol &, 37 uint64_t entryAddr) const override; 38 39 void relaxGotLoad(uint8_t *loc, uint8_t type) const override; 40 const RelocAttrs &getRelocAttrs(uint8_t type) const override; 41 uint64_t getPageSize() const override { return 4 * 1024; } 42 }; 43 44 } // namespace 45 46 const RelocAttrs &X86_64::getRelocAttrs(uint8_t type) const { 47 static const std::array<RelocAttrs, 10> relocAttrsArray{{ 48 #define B(x) RelocAttrBits::x 49 {"UNSIGNED", 50 B(UNSIGNED) | B(ABSOLUTE) | B(EXTERN) | B(LOCAL) | B(BYTE4) | B(BYTE8)}, 51 {"SIGNED", B(PCREL) | B(EXTERN) | B(LOCAL) | B(BYTE4)}, 52 {"BRANCH", B(PCREL) | B(EXTERN) | B(BRANCH) | B(BYTE4)}, 53 {"GOT_LOAD", B(PCREL) | B(EXTERN) | B(GOT) | B(LOAD) | B(BYTE4)}, 54 {"GOT", B(PCREL) | B(EXTERN) | B(GOT) | B(POINTER) | B(BYTE4)}, 55 {"SUBTRACTOR", B(SUBTRAHEND) | B(EXTERN) | B(BYTE4) | B(BYTE8)}, 56 {"SIGNED_1", B(PCREL) | B(EXTERN) | B(LOCAL) | B(BYTE4)}, 57 {"SIGNED_2", B(PCREL) | B(EXTERN) | B(LOCAL) | B(BYTE4)}, 58 {"SIGNED_4", B(PCREL) | B(EXTERN) | B(LOCAL) | B(BYTE4)}, 59 {"TLV", B(PCREL) | B(EXTERN) | B(TLV) | B(LOAD) | B(BYTE4)}, 60 #undef B 61 }}; 62 assert(type < relocAttrsArray.size() && "invalid relocation type"); 63 if (type >= relocAttrsArray.size()) 64 return invalidRelocAttrs; 65 return relocAttrsArray[type]; 66 } 67 68 static int pcrelOffset(uint8_t type) { 69 switch (type) { 70 case X86_64_RELOC_SIGNED_1: 71 return 1; 72 case X86_64_RELOC_SIGNED_2: 73 return 2; 74 case X86_64_RELOC_SIGNED_4: 75 return 4; 76 default: 77 return 0; 78 } 79 } 80 81 int64_t X86_64::getEmbeddedAddend(MemoryBufferRef mb, uint64_t offset, 82 relocation_info rel) const { 83 auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart()); 84 const uint8_t *loc = buf + offset + rel.r_address; 85 86 switch (rel.r_length) { 87 case 2: 88 return static_cast<int32_t>(read32le(loc)) + pcrelOffset(rel.r_type); 89 case 3: 90 return read64le(loc) + pcrelOffset(rel.r_type); 91 default: 92 llvm_unreachable("invalid r_length"); 93 } 94 } 95 96 void X86_64::relocateOne(uint8_t *loc, const Reloc &r, uint64_t value, 97 uint64_t relocVA) const { 98 if (r.pcrel) { 99 uint64_t pc = relocVA + 4 + pcrelOffset(r.type); 100 value -= pc; 101 } 102 103 switch (r.length) { 104 case 2: 105 if (r.type == X86_64_RELOC_UNSIGNED) 106 checkUInt(loc, r, value, 32); 107 else 108 checkInt(loc, r, value, 32); 109 write32le(loc, value); 110 break; 111 case 3: 112 write64le(loc, value); 113 break; 114 default: 115 llvm_unreachable("invalid r_length"); 116 } 117 } 118 119 // The following methods emit a number of assembly sequences with RIP-relative 120 // addressing. Note that RIP-relative addressing on X86-64 has the RIP pointing 121 // to the next instruction, not the current instruction, so we always have to 122 // account for the current instruction's size when calculating offsets. 123 // writeRipRelative helps with that. 124 // 125 // bufAddr: The virtual address corresponding to buf[0]. 126 // bufOff: The offset within buf of the next instruction. 127 // destAddr: The destination address that the current instruction references. 128 static void writeRipRelative(SymbolDiagnostic d, uint8_t *buf, uint64_t bufAddr, 129 uint64_t bufOff, uint64_t destAddr) { 130 uint64_t rip = bufAddr + bufOff; 131 checkInt(buf, d, destAddr - rip, 32); 132 // For the instructions we care about, the RIP-relative address is always 133 // stored in the last 4 bytes of the instruction. 134 write32le(buf + bufOff - 4, destAddr - rip); 135 } 136 137 static constexpr uint8_t stub[] = { 138 0xff, 0x25, 0, 0, 0, 0, // jmpq *__la_symbol_ptr(%rip) 139 }; 140 141 void X86_64::writeStub(uint8_t *buf, const Symbol &sym) const { 142 memcpy(buf, stub, 2); // just copy the two nonzero bytes 143 uint64_t stubAddr = in.stubs->addr + sym.stubsIndex * sizeof(stub); 144 writeRipRelative({&sym, "stub"}, buf, stubAddr, sizeof(stub), 145 in.lazyPointers->addr + sym.stubsIndex * LP64::wordSize); 146 } 147 148 static constexpr uint8_t stubHelperHeader[] = { 149 0x4c, 0x8d, 0x1d, 0, 0, 0, 0, // 0x0: leaq ImageLoaderCache(%rip), %r11 150 0x41, 0x53, // 0x7: pushq %r11 151 0xff, 0x25, 0, 0, 0, 0, // 0x9: jmpq *dyld_stub_binder@GOT(%rip) 152 0x90, // 0xf: nop 153 }; 154 155 void X86_64::writeStubHelperHeader(uint8_t *buf) const { 156 memcpy(buf, stubHelperHeader, sizeof(stubHelperHeader)); 157 SymbolDiagnostic d = {nullptr, "stub helper header"}; 158 writeRipRelative(d, buf, in.stubHelper->addr, 7, 159 in.imageLoaderCache->getVA()); 160 writeRipRelative(d, buf, in.stubHelper->addr, 0xf, 161 in.got->addr + 162 in.stubHelper->stubBinder->gotIndex * LP64::wordSize); 163 } 164 165 static constexpr uint8_t stubHelperEntry[] = { 166 0x68, 0, 0, 0, 0, // 0x0: pushq <bind offset> 167 0xe9, 0, 0, 0, 0, // 0x5: jmp <__stub_helper> 168 }; 169 170 void X86_64::writeStubHelperEntry(uint8_t *buf, const Symbol &sym, 171 uint64_t entryAddr) const { 172 memcpy(buf, stubHelperEntry, sizeof(stubHelperEntry)); 173 write32le(buf + 1, sym.lazyBindOffset); 174 writeRipRelative({&sym, "stub helper"}, buf, entryAddr, 175 sizeof(stubHelperEntry), in.stubHelper->addr); 176 } 177 178 void X86_64::relaxGotLoad(uint8_t *loc, uint8_t type) const { 179 // Convert MOVQ to LEAQ 180 if (loc[-2] != 0x8b) 181 error(getRelocAttrs(type).name + " reloc requires MOVQ instruction"); 182 loc[-2] = 0x8d; 183 } 184 185 X86_64::X86_64() : TargetInfo(LP64()) { 186 cpuType = CPU_TYPE_X86_64; 187 cpuSubtype = CPU_SUBTYPE_X86_64_ALL; 188 189 modeDwarfEncoding = UNWIND_X86_MODE_DWARF; 190 subtractorRelocType = X86_64_RELOC_SUBTRACTOR; 191 unsignedRelocType = X86_64_RELOC_UNSIGNED; 192 193 stubSize = sizeof(stub); 194 stubHelperHeaderSize = sizeof(stubHelperHeader); 195 stubHelperEntrySize = sizeof(stubHelperEntry); 196 } 197 198 TargetInfo *macho::createX86_64TargetInfo() { 199 static X86_64 t; 200 return &t; 201 } 202