LLVM 20.0.0git
MachOObject.h
Go to the documentation of this file.
1//===- MachOObject.h - Mach-O object file model -----------------*- C++ -*-===//
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#ifndef LLVM_LIB_OBJCOPY_MACHO_MACHOOBJECT_H
10#define LLVM_LIB_OBJCOPY_MACHO_MACHOOBJECT_H
11
12#include "llvm/ADT/StringRef.h"
18#include <cstdint>
19#include <string>
20#include <vector>
21
22namespace llvm {
23namespace objcopy {
24namespace macho {
25
26struct MachHeader {
35};
36
37struct RelocationInfo;
38struct Section {
40 std::string Segname;
41 std::string Sectname;
42 // CanonicalName is a string formatted as “<Segname>,<Sectname>".
43 std::string CanonicalName;
46 // Offset in the input file.
47 std::optional<uint32_t> OriginalOffset;
57 std::vector<RelocationInfo> Relocations;
58
59 Section(StringRef SegName, StringRef SectName);
60
61 Section(StringRef SegName, StringRef SectName, StringRef Content);
62
64 return static_cast<MachO::SectionType>(Flags & MachO::SECTION_TYPE);
65 }
66
67 bool isVirtualSection() const {
68 return (getType() == MachO::S_ZEROFILL ||
71 }
72
73 bool hasValidOffset() const {
74 return !(isVirtualSection() || (OriginalOffset && *OriginalOffset == 0));
75 }
76};
77
79 // The type MachO::macho_load_command is defined in llvm/BinaryFormat/MachO.h
80 // and it is a union of all the structs corresponding to various load
81 // commands.
83
84 // The raw content of the payload of the load command (located right after the
85 // corresponding struct). In some cases it is either empty or can be
86 // copied-over without digging into its structure.
87 std::vector<uint8_t> Payload;
88
89 // Some load commands can contain (inside the payload) an array of sections,
90 // though the contents of the sections are stored separately. The struct
91 // Section describes only sections' metadata and where to find the
92 // corresponding content inside the binary.
93 std::vector<std::unique_ptr<Section>> Sections;
94
95 // Returns the segment name if the load command is a segment command.
96 std::optional<StringRef> getSegmentName() const;
97
98 // Returns the segment vm address if the load command is a segment command.
99 std::optional<uint64_t> getSegmentVMAddr() const;
100};
101
102// A symbol information. Fields which starts with "n_" are same as them in the
103// nlist.
105 std::string Name;
106 bool Referenced = false;
108 uint8_t n_type;
109 uint8_t n_sect;
112
113 bool isExternalSymbol() const { return n_type & MachO::N_EXT; }
114
115 bool isLocalSymbol() const { return !isExternalSymbol(); }
116
117 bool isUndefinedSymbol() const {
118 return (n_type & MachO::N_TYPE) == MachO::N_UNDF;
119 }
120
121 bool isSwiftSymbol() const {
122 return StringRef(Name).starts_with("_$s") ||
123 StringRef(Name).starts_with("_$S");
124 }
125
126 std::optional<uint32_t> section() const {
127 return n_sect == MachO::NO_SECT ? std::nullopt
128 : std::optional<uint32_t>(n_sect);
129 }
130};
131
132/// The location of the symbol table inside the binary is described by LC_SYMTAB
133/// load command.
135 std::vector<std::unique_ptr<SymbolEntry>> Symbols;
136
138 std::vector<std::unique_ptr<SymbolEntry>>::const_iterator>;
139
140 iterator begin() const { return iterator(Symbols.begin()); }
141 iterator end() const { return iterator(Symbols.end()); }
142
145 void removeSymbols(
146 function_ref<bool(const std::unique_ptr<SymbolEntry> &)> ToRemove);
147};
148
150 // The original value in an indirect symbol table. Higher bits encode extra
151 // information (INDIRECT_SYMBOL_LOCAL and INDIRECT_SYMBOL_ABS).
153 /// The Symbol referenced by this entry. It's std::nullopt if the index is
154 /// INDIRECT_SYMBOL_LOCAL or INDIRECT_SYMBOL_ABS.
155 std::optional<SymbolEntry *> Symbol;
156
158 std::optional<SymbolEntry *> Symbol)
160};
161
163 std::vector<IndirectSymbolEntry> Symbols;
164};
165
166/// The location of the string table inside the binary is described by LC_SYMTAB
167/// load command.
169 std::vector<std::string> Strings;
170};
171
173 // The referenced symbol entry. Set if !Scattered && Extern.
174 std::optional<const SymbolEntry *> Symbol;
175 // The referenced section. Set if !Scattered && !Extern.
176 std::optional<const Section *> Sec;
177 // True if Info is a scattered_relocation_info.
179 // True if the type is an ADDEND. r_symbolnum holds the addend instead of a
180 // symbol index.
182 // True if the r_symbolnum points to a section number (i.e. r_extern=0).
183 bool Extern;
185
186 unsigned getPlainRelocationSymbolNum(bool IsLittleEndian) {
187 if (IsLittleEndian)
188 return Info.r_word1 & 0xffffff;
189 return Info.r_word1 >> 8;
190 }
191
192 void setPlainRelocationSymbolNum(unsigned SymbolNum, bool IsLittleEndian) {
193 assert(SymbolNum < (1 << 24) && "SymbolNum out of range");
194 if (IsLittleEndian)
195 Info.r_word1 = (Info.r_word1 & ~0x00ffffff) | SymbolNum;
196 else
197 Info.r_word1 = (Info.r_word1 & ~0xffffff00) | (SymbolNum << 8);
198 }
199};
200
201/// The location of the rebase info inside the binary is described by
202/// LC_DYLD_INFO load command. Dyld rebases an image whenever dyld loads it at
203/// an address different from its preferred address. The rebase information is
204/// a stream of byte sized opcodes whose symbolic names start with
205/// REBASE_OPCODE_. Conceptually the rebase information is a table of tuples:
206/// <seg-index, seg-offset, type>
207/// The opcodes are a compressed way to encode the table by only
208/// encoding when a column changes. In addition simple patterns
209/// like "every n'th offset for m times" can be encoded in a few
210/// bytes.
212 // At the moment we do not parse this info (and it is simply copied over),
213 // but the proper support will be added later.
215};
216
217/// The location of the bind info inside the binary is described by
218/// LC_DYLD_INFO load command. Dyld binds an image during the loading process,
219/// if the image requires any pointers to be initialized to symbols in other
220/// images. The bind information is a stream of byte sized opcodes whose
221/// symbolic names start with BIND_OPCODE_. Conceptually the bind information is
222/// a table of tuples: <seg-index, seg-offset, type, symbol-library-ordinal,
223/// symbol-name, addend> The opcodes are a compressed way to encode the table by
224/// only encoding when a column changes. In addition simple patterns like for
225/// runs of pointers initialized to the same value can be encoded in a few
226/// bytes.
227struct BindInfo {
228 // At the moment we do not parse this info (and it is simply copied over),
229 // but the proper support will be added later.
231};
232
233/// The location of the weak bind info inside the binary is described by
234/// LC_DYLD_INFO load command. Some C++ programs require dyld to unique symbols
235/// so that all images in the process use the same copy of some code/data. This
236/// step is done after binding. The content of the weak_bind info is an opcode
237/// stream like the bind_info. But it is sorted alphabetically by symbol name.
238/// This enable dyld to walk all images with weak binding information in order
239/// and look for collisions. If there are no collisions, dyld does no updating.
240/// That means that some fixups are also encoded in the bind_info. For
241/// instance, all calls to "operator new" are first bound to libstdc++.dylib
242/// using the information in bind_info. Then if some image overrides operator
243/// new that is detected when the weak_bind information is processed and the
244/// call to operator new is then rebound.
246 // At the moment we do not parse this info (and it is simply copied over),
247 // but the proper support will be added later.
249};
250
251/// The location of the lazy bind info inside the binary is described by
252/// LC_DYLD_INFO load command. Some uses of external symbols do not need to be
253/// bound immediately. Instead they can be lazily bound on first use. The
254/// lazy_bind contains a stream of BIND opcodes to bind all lazy symbols. Normal
255/// use is that dyld ignores the lazy_bind section when loading an image.
256/// Instead the static linker arranged for the lazy pointer to initially point
257/// to a helper function which pushes the offset into the lazy_bind area for the
258/// symbol needing to be bound, then jumps to dyld which simply adds the offset
259/// to lazy_bind_off to get the information on what to bind.
262};
263
264/// The location of the export info inside the binary is described by
265/// LC_DYLD_INFO load command. The symbols exported by a dylib are encoded in a
266/// trie. This is a compact representation that factors out common prefixes. It
267/// also reduces LINKEDIT pages in RAM because it encodes all information (name,
268/// address, flags) in one small, contiguous range. The export area is a stream
269/// of nodes. The first node sequentially is the start node for the trie. Nodes
270/// for a symbol start with a uleb128 that is the length of the exported symbol
271/// information for the string so far. If there is no exported symbol, the node
272/// starts with a zero byte. If there is exported info, it follows the length.
273/// First is a uleb128 containing flags. Normally, it is followed by
274/// a uleb128 encoded offset which is location of the content named
275/// by the symbol from the mach_header for the image. If the flags
276/// is EXPORT_SYMBOL_FLAGS_REEXPORT, then following the flags is
277/// a uleb128 encoded library ordinal, then a zero terminated
278/// UTF8 string. If the string is zero length, then the symbol
279/// is re-export from the specified dylib with the same name.
280/// If the flags is EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER, then following
281/// the flags is two uleb128s: the stub offset and the resolver offset.
282/// The stub is used by non-lazy pointers. The resolver is used
283/// by lazy pointers and must be called to get the actual address to use.
284/// After the optional exported symbol information is a byte of
285/// how many edges (0-255) that this node has leaving it,
286/// followed by each edge.
287/// Each edge is a zero terminated UTF8 of the addition chars
288/// in the symbol, followed by a uleb128 offset for the node that
289/// edge points to.
292};
293
294struct LinkData {
296};
297
298struct Object {
300 std::vector<LoadCommand> LoadCommands;
301
304
317
318 std::optional<uint32_t> SwiftVersion;
319
320 /// The index of LC_CODE_SIGNATURE load command if present.
321 std::optional<size_t> CodeSignatureCommandIndex;
322 /// The index of LC_DYLIB_CODE_SIGN_DRS load command if present.
323 std::optional<size_t> DylibCodeSignDRsIndex;
324 /// The index of LC_SYMTAB load command if present.
325 std::optional<size_t> SymTabCommandIndex;
326 /// The index of LC_DYLD_INFO or LC_DYLD_INFO_ONLY load command if present.
327 std::optional<size_t> DyLdInfoCommandIndex;
328 /// The index LC_DYSYMTAB load command if present.
329 std::optional<size_t> DySymTabCommandIndex;
330 /// The index LC_DATA_IN_CODE load command if present.
331 std::optional<size_t> DataInCodeCommandIndex;
332 /// The index of LC_LINKER_OPTIMIZATIN_HINT load command if present.
334 /// The index LC_FUNCTION_STARTS load command if present.
335 std::optional<size_t> FunctionStartsCommandIndex;
336 /// The index LC_DYLD_CHAINED_FIXUPS load command if present.
337 std::optional<size_t> ChainedFixupsCommandIndex;
338 /// The index LC_DYLD_EXPORTS_TRIE load command if present.
339 std::optional<size_t> ExportsTrieCommandIndex;
340 /// The index of the LC_SEGMENT or LC_SEGMENT_64 load command
341 /// corresponding to the __TEXT segment.
342 std::optional<size_t> TextSegmentCommandIndex;
343
346
348
349 Error
350 removeSections(function_ref<bool(const std::unique_ptr<Section> &)> ToRemove);
351
353
355
356 /// Creates a new segment load command in the object and returns a reference
357 /// to the newly created load command. The caller should verify that SegName
358 /// is not too long (SegName.size() should be less than or equal to 16).
359 LoadCommand &addSegment(StringRef SegName, uint64_t SegVMSize);
360
361 bool is64Bit() const {
362 return Header.Magic == MachO::MH_MAGIC_64 ||
364 }
365
367};
368
369} // end namespace macho
370} // end namespace objcopy
371} // end namespace llvm
372
373#endif // LLVM_LIB_OBJCOPY_MACHO_MACHOOBJECT_H
ReachingDefAnalysis InstSet & ToRemove
This file declares classes for handling the YAML representation of DWARF Debug Info.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:250
Saves strings in the provided stable storage and returns a StringRef with a stable character pointer.
Definition: StringSaver.h:21
An efficient, type-erasing, non-owning reference to a callable.
@ SECTION_TYPE
Definition: MachO.h:114
@ NO_SECT
Definition: MachO.h:326
SectionType
These are the section type and attributes fields.
Definition: MachO.h:122
@ S_GB_ZEROFILL
S_GB_ZEROFILL - Zero fill on demand section (that can be larger than 4 gigabytes).
Definition: MachO.h:155
@ S_THREAD_LOCAL_ZEROFILL
S_THREAD_LOCAL_ZEROFILL - Thread local zerofill section.
Definition: MachO.h:169
@ S_ZEROFILL
S_ZEROFILL - Zero fill on demand section.
Definition: MachO.h:129
@ MH_CIGAM_64
Definition: MachO.h:33
@ MH_MAGIC_64
Definition: MachO.h:32
@ N_UNDF
Definition: MachO.h:316
@ N_TYPE
Definition: MachO.h:309
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
The location of the bind info inside the binary is described by LC_DYLD_INFO load command.
Definition: MachOObject.h:227
ArrayRef< uint8_t > Opcodes
Definition: MachOObject.h:230
The location of the export info inside the binary is described by LC_DYLD_INFO load command.
Definition: MachOObject.h:290
std::optional< SymbolEntry * > Symbol
The Symbol referenced by this entry.
Definition: MachOObject.h:155
IndirectSymbolEntry(uint32_t OriginalIndex, std::optional< SymbolEntry * > Symbol)
Definition: MachOObject.h:157
std::vector< IndirectSymbolEntry > Symbols
Definition: MachOObject.h:163
The location of the lazy bind info inside the binary is described by LC_DYLD_INFO load command.
Definition: MachOObject.h:260
ArrayRef< uint8_t > Data
Definition: MachOObject.h:295
MachO::macho_load_command MachOLoadCommand
Definition: MachOObject.h:82
std::optional< StringRef > getSegmentName() const
std::vector< std::unique_ptr< Section > > Sections
Definition: MachOObject.h:93
std::optional< uint64_t > getSegmentVMAddr() const
std::vector< uint8_t > Payload
Definition: MachOObject.h:87
std::optional< size_t > FunctionStartsCommandIndex
The index LC_FUNCTION_STARTS load command if present.
Definition: MachOObject.h:335
Error removeLoadCommands(function_ref< bool(const LoadCommand &)> ToRemove)
Definition: MachOObject.cpp:92
std::optional< size_t > ChainedFixupsCommandIndex
The index LC_DYLD_CHAINED_FIXUPS load command if present.
Definition: MachOObject.h:337
std::optional< size_t > ExportsTrieCommandIndex
The index LC_DYLD_EXPORTS_TRIE load command if present.
Definition: MachOObject.h:339
Error removeSections(function_ref< bool(const std::unique_ptr< Section > &)> ToRemove)
std::optional< size_t > DylibCodeSignDRsIndex
The index of LC_DYLIB_CODE_SIGN_DRS load command if present.
Definition: MachOObject.h:323
std::optional< size_t > SymTabCommandIndex
The index of LC_SYMTAB load command if present.
Definition: MachOObject.h:325
std::optional< size_t > DyLdInfoCommandIndex
The index of LC_DYLD_INFO or LC_DYLD_INFO_ONLY load command if present.
Definition: MachOObject.h:327
std::vector< LoadCommand > LoadCommands
Definition: MachOObject.h:300
std::optional< size_t > DataInCodeCommandIndex
The index LC_DATA_IN_CODE load command if present.
Definition: MachOObject.h:331
std::optional< uint32_t > SwiftVersion
Definition: MachOObject.h:318
std::optional< size_t > DySymTabCommandIndex
The index LC_DYSYMTAB load command if present.
Definition: MachOObject.h:329
std::optional< size_t > TextSegmentCommandIndex
The index of the LC_SEGMENT or LC_SEGMENT_64 load command corresponding to the __TEXT segment.
Definition: MachOObject.h:342
IndirectSymbolTable IndirectSymTable
Definition: MachOObject.h:310
uint64_t nextAvailableSegmentAddress() const
std::optional< size_t > CodeSignatureCommandIndex
The index of LC_CODE_SIGNATURE load command if present.
Definition: MachOObject.h:321
LoadCommand & addSegment(StringRef SegName, uint64_t SegVMSize)
Creates a new segment load command in the object and returns a reference to the newly created load co...
std::optional< size_t > LinkerOptimizationHintCommandIndex
The index of LC_LINKER_OPTIMIZATIN_HINT load command if present.
Definition: MachOObject.h:333
The location of the rebase info inside the binary is described by LC_DYLD_INFO load command.
Definition: MachOObject.h:211
ArrayRef< uint8_t > Opcodes
Definition: MachOObject.h:214
MachO::any_relocation_info Info
Definition: MachOObject.h:184
std::optional< const SymbolEntry * > Symbol
Definition: MachOObject.h:174
std::optional< const Section * > Sec
Definition: MachOObject.h:176
unsigned getPlainRelocationSymbolNum(bool IsLittleEndian)
Definition: MachOObject.h:186
void setPlainRelocationSymbolNum(unsigned SymbolNum, bool IsLittleEndian)
Definition: MachOObject.h:192
std::optional< uint32_t > OriginalOffset
Definition: MachOObject.h:47
std::vector< RelocationInfo > Relocations
Definition: MachOObject.h:57
MachO::SectionType getType() const
Definition: MachOObject.h:63
The location of the string table inside the binary is described by LC_SYMTAB load command.
Definition: MachOObject.h:168
std::vector< std::string > Strings
Definition: MachOObject.h:169
std::optional< uint32_t > section() const
Definition: MachOObject.h:126
The location of the symbol table inside the binary is described by LC_SYMTAB load command.
Definition: MachOObject.h:134
const SymbolEntry * getSymbolByIndex(uint32_t Index) const
Definition: MachOObject.cpp:26
std::vector< std::unique_ptr< SymbolEntry > > Symbols
Definition: MachOObject.h:135
pointee_iterator< std::vector< std::unique_ptr< SymbolEntry > >::const_iterator > iterator
Definition: MachOObject.h:138
void removeSymbols(function_ref< bool(const std::unique_ptr< SymbolEntry > &)> ToRemove)
Definition: MachOObject.cpp:36
The location of the weak bind info inside the binary is described by LC_DYLD_INFO load command.
Definition: MachOObject.h:245
An iterator type that allows iterating over the pointees via some other iterator.
Definition: iterator.h:324