1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
//===- Target.h -------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLD_MACHO_TARGET_H
#define LLD_MACHO_TARGET_H
#include "MachOStructs.h"
#include "Relocations.h"
#include "llvm/ADT/BitmaskEnum.h"
#include "llvm/BinaryFormat/MachO.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/MemoryBuffer.h"
#include <cstddef>
#include <cstdint>
namespace lld {
namespace macho {
LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
class Symbol;
class Defined;
class DylibSymbol;
class InputSection;
class ConcatInputSection;
class TargetInfo {
public:
template <class LP> TargetInfo(LP) {
// Having these values available in TargetInfo allows us to access them
// without having to resort to templates.
magic = LP::magic;
pageZeroSize = LP::pageZeroSize;
headerSize = sizeof(typename LP::mach_header);
wordSize = LP::wordSize;
p2WordSize = llvm::CTLog2<LP::wordSize>();
}
virtual ~TargetInfo() = default;
// Validate the relocation structure and get its addend.
virtual int64_t
getEmbeddedAddend(llvm::MemoryBufferRef, uint64_t offset,
const llvm::MachO::relocation_info) const = 0;
virtual void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
uint64_t relocVA) const = 0;
// Write code for lazy binding. See the comments on StubsSection for more
// details.
virtual void writeStub(uint8_t *buf, const Symbol &) const = 0;
virtual void writeStubHelperHeader(uint8_t *buf) const = 0;
virtual void writeStubHelperEntry(uint8_t *buf, const Symbol &,
uint64_t entryAddr) const = 0;
// Symbols may be referenced via either the GOT or the stubs section,
// depending on the relocation type. prepareSymbolRelocation() will set up the
// GOT/stubs entries, and resolveSymbolVA() will return the addresses of those
// entries. resolveSymbolVA() may also relax the target instructions to save
// on a level of address indirection.
virtual void relaxGotLoad(uint8_t *loc, uint8_t type) const = 0;
virtual uint64_t getPageSize() const = 0;
virtual void populateThunk(InputSection *thunk, Symbol *funcSym) {
llvm_unreachable("target does not use thunks");
}
const RelocAttrs &getRelocAttrs(uint8_t type) const {
assert(type < relocAttrs.size() && "invalid relocation type");
if (type >= relocAttrs.size())
return invalidRelocAttrs;
return relocAttrs[type];
}
bool hasAttr(uint8_t type, RelocAttrBits bit) const {
return getRelocAttrs(type).hasAttr(bit);
}
bool usesThunks() const { return thunkSize > 0; }
// For now, handleDtraceReloc only implements -no_dtrace_dof, and ensures
// that the linking would not fail even when there are user-provided dtrace
// symbols. However, unlike ld64, lld currently does not emit __dof sections.
virtual void handleDtraceReloc(const Symbol *sym, const Reloc &r,
uint8_t *loc) const {
llvm_unreachable("Unsupported architecture for dtrace symbols");
}
virtual void applyOptimizationHints(uint8_t *buf, const ConcatInputSection *,
llvm::ArrayRef<uint64_t>) const {};
uint32_t magic;
llvm::MachO::CPUType cpuType;
uint32_t cpuSubtype;
uint64_t pageZeroSize;
size_t headerSize;
size_t stubSize;
size_t stubHelperHeaderSize;
size_t stubHelperEntrySize;
uint8_t p2WordSize;
size_t wordSize;
size_t thunkSize = 0;
uint64_t forwardBranchRange = 0;
uint64_t backwardBranchRange = 0;
uint32_t modeDwarfEncoding;
uint8_t subtractorRelocType;
uint8_t unsignedRelocType;
llvm::ArrayRef<RelocAttrs> relocAttrs;
// We contrive this value as sufficiently far from any valid address that it
// will always be out-of-range for any architecture. UINT64_MAX is not a
// good choice because it is (a) only 1 away from wrapping to 0, and (b) the
// tombstone value for DenseMap<> and caused weird assertions for me.
static constexpr uint64_t outOfRangeVA = 0xfull << 60;
};
TargetInfo *createX86_64TargetInfo();
TargetInfo *createARM64TargetInfo();
TargetInfo *createARM64_32TargetInfo();
TargetInfo *createARMTargetInfo(uint32_t cpuSubtype);
struct LP64 {
using mach_header = llvm::MachO::mach_header_64;
using nlist = structs::nlist_64;
using segment_command = llvm::MachO::segment_command_64;
using section = llvm::MachO::section_64;
using encryption_info_command = llvm::MachO::encryption_info_command_64;
static constexpr uint32_t magic = llvm::MachO::MH_MAGIC_64;
static constexpr uint32_t segmentLCType = llvm::MachO::LC_SEGMENT_64;
static constexpr uint32_t encryptionInfoLCType =
llvm::MachO::LC_ENCRYPTION_INFO_64;
static constexpr uint64_t pageZeroSize = 1ull << 32;
static constexpr size_t wordSize = 8;
};
struct ILP32 {
using mach_header = llvm::MachO::mach_header;
using nlist = structs::nlist;
using segment_command = llvm::MachO::segment_command;
using section = llvm::MachO::section;
using encryption_info_command = llvm::MachO::encryption_info_command;
static constexpr uint32_t magic = llvm::MachO::MH_MAGIC;
static constexpr uint32_t segmentLCType = llvm::MachO::LC_SEGMENT;
static constexpr uint32_t encryptionInfoLCType =
llvm::MachO::LC_ENCRYPTION_INFO;
static constexpr uint64_t pageZeroSize = 1ull << 12;
static constexpr size_t wordSize = 4;
};
extern TargetInfo *target;
} // namespace macho
} // namespace lld
#endif
|
