1 //===- MachOObject.cpp - Mach-O Object File Wrapper -----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/Object/MachOObject.h"
11 #include "llvm/ADT/SmallVector.h"
12 #include "llvm/ADT/StringRef.h"
13 #include "llvm/Support/DataExtractor.h"
14 #include "llvm/Support/Debug.h"
15 #include "llvm/Support/Host.h"
16 #include "llvm/Support/MemoryBuffer.h"
17 #include "llvm/Support/SwapByteOrder.h"
18 #include "llvm/Support/raw_ostream.h"
21 using namespace llvm::object;
23 /* Translation Utilities */
26 static void SwapValue(T &Value) {
27 Value = sys::SwapByteOrder(Value);
31 static void SwapStruct(T &Value);
34 static void ReadInMemoryStruct(const MachOObject &MOO,
35 StringRef Buffer, uint64_t Base,
36 InMemoryStruct<T> &Res) {
37 typedef T struct_type;
38 uint64_t Size = sizeof(struct_type);
40 // Check that the buffer contains the expected data.
41 if (Base + Size > Buffer.size()) {
46 // Check whether we can return a direct pointer.
47 struct_type *Ptr = reinterpret_cast<struct_type *>(
48 const_cast<char *>(Buffer.data() + Base));
49 if (!MOO.isSwappedEndian()) {
54 // Otherwise, copy the struct and translate the values.
61 MachOObject::MachOObject(MemoryBuffer *Buffer_, bool IsLittleEndian_,
63 : Buffer(Buffer_), IsLittleEndian(IsLittleEndian_), Is64Bit(Is64Bit_),
64 IsSwappedEndian(IsLittleEndian != sys::IsLittleEndianHost),
65 HasStringTable(false), LoadCommands(0), NumLoadedCommands(0) {
66 // Load the common header.
67 memcpy(&Header, Buffer->getBuffer().data(), sizeof(Header));
68 if (IsSwappedEndian) {
69 SwapValue(Header.Magic);
70 SwapValue(Header.CPUType);
71 SwapValue(Header.CPUSubtype);
72 SwapValue(Header.FileType);
73 SwapValue(Header.NumLoadCommands);
74 SwapValue(Header.SizeOfLoadCommands);
75 SwapValue(Header.Flags);
79 memcpy(&Header64Ext, Buffer->getBuffer().data() + sizeof(Header),
81 if (IsSwappedEndian) {
82 SwapValue(Header64Ext.Reserved);
86 // Create the load command array if sane.
87 if (getHeader().NumLoadCommands < (1 << 20))
88 LoadCommands = new LoadCommandInfo[getHeader().NumLoadCommands];
91 MachOObject::~MachOObject() {
92 delete [] LoadCommands;
95 MachOObject *MachOObject::LoadFromBuffer(MemoryBuffer *Buffer,
96 std::string *ErrorStr) {
97 // First, check the magic value and initialize the basic object info.
98 bool IsLittleEndian = false, Is64Bit = false;
99 StringRef Magic = Buffer->getBuffer().slice(0, 4);
100 if (Magic == "\xFE\xED\xFA\xCE") {
101 } else if (Magic == "\xCE\xFA\xED\xFE") {
102 IsLittleEndian = true;
103 } else if (Magic == "\xFE\xED\xFA\xCF") {
105 } else if (Magic == "\xCF\xFA\xED\xFE") {
106 IsLittleEndian = true;
109 if (ErrorStr) *ErrorStr = "not a Mach object file (invalid magic)";
113 // Ensure that the at least the full header is present.
114 unsigned HeaderSize = Is64Bit ? macho::Header64Size : macho::Header32Size;
115 if (Buffer->getBufferSize() < HeaderSize) {
116 if (ErrorStr) *ErrorStr = "not a Mach object file (invalid header)";
120 OwningPtr<MachOObject> Object(new MachOObject(Buffer, IsLittleEndian,
123 // Check for bogus number of load commands.
124 if (Object->getHeader().NumLoadCommands >= (1 << 20)) {
125 if (ErrorStr) *ErrorStr = "not a Mach object file (unreasonable header)";
129 if (ErrorStr) *ErrorStr = "";
130 return Object.take();
133 StringRef MachOObject::getData(size_t Offset, size_t Size) const {
134 return Buffer->getBuffer().substr(Offset,Size);
137 void MachOObject::RegisterStringTable(macho::SymtabLoadCommand &SLC) {
138 HasStringTable = true;
139 StringTable = Buffer->getBuffer().substr(SLC.StringTableOffset,
140 SLC.StringTableSize);
143 const MachOObject::LoadCommandInfo &
144 MachOObject::getLoadCommandInfo(unsigned Index) const {
145 assert(Index < getHeader().NumLoadCommands && "Invalid index!");
147 // Load the command, if necessary.
148 if (Index >= NumLoadedCommands) {
151 Offset = getHeaderSize();
153 const LoadCommandInfo &Prev = getLoadCommandInfo(Index - 1);
154 Offset = Prev.Offset + Prev.Command.Size;
157 LoadCommandInfo &Info = LoadCommands[Index];
158 memcpy(&Info.Command, Buffer->getBuffer().data() + Offset,
159 sizeof(macho::LoadCommand));
160 if (IsSwappedEndian) {
161 SwapValue(Info.Command.Type);
162 SwapValue(Info.Command.Size);
164 Info.Offset = Offset;
165 NumLoadedCommands = Index + 1;
168 return LoadCommands[Index];
172 void SwapStruct(macho::SegmentLoadCommand &Value) {
173 SwapValue(Value.Type);
174 SwapValue(Value.Size);
175 SwapValue(Value.VMAddress);
176 SwapValue(Value.VMSize);
177 SwapValue(Value.FileOffset);
178 SwapValue(Value.FileSize);
179 SwapValue(Value.MaxVMProtection);
180 SwapValue(Value.InitialVMProtection);
181 SwapValue(Value.NumSections);
182 SwapValue(Value.Flags);
184 void MachOObject::ReadSegmentLoadCommand(const LoadCommandInfo &LCI,
185 InMemoryStruct<macho::SegmentLoadCommand> &Res) const {
186 ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
190 void SwapStruct(macho::Segment64LoadCommand &Value) {
191 SwapValue(Value.Type);
192 SwapValue(Value.Size);
193 SwapValue(Value.VMAddress);
194 SwapValue(Value.VMSize);
195 SwapValue(Value.FileOffset);
196 SwapValue(Value.FileSize);
197 SwapValue(Value.MaxVMProtection);
198 SwapValue(Value.InitialVMProtection);
199 SwapValue(Value.NumSections);
200 SwapValue(Value.Flags);
202 void MachOObject::ReadSegment64LoadCommand(const LoadCommandInfo &LCI,
203 InMemoryStruct<macho::Segment64LoadCommand> &Res) const {
204 ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
208 void SwapStruct(macho::SymtabLoadCommand &Value) {
209 SwapValue(Value.Type);
210 SwapValue(Value.Size);
211 SwapValue(Value.SymbolTableOffset);
212 SwapValue(Value.NumSymbolTableEntries);
213 SwapValue(Value.StringTableOffset);
214 SwapValue(Value.StringTableSize);
216 void MachOObject::ReadSymtabLoadCommand(const LoadCommandInfo &LCI,
217 InMemoryStruct<macho::SymtabLoadCommand> &Res) const {
218 ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
222 void SwapStruct(macho::DysymtabLoadCommand &Value) {
223 SwapValue(Value.Type);
224 SwapValue(Value.Size);
225 SwapValue(Value.LocalSymbolsIndex);
226 SwapValue(Value.NumLocalSymbols);
227 SwapValue(Value.ExternalSymbolsIndex);
228 SwapValue(Value.NumExternalSymbols);
229 SwapValue(Value.UndefinedSymbolsIndex);
230 SwapValue(Value.NumUndefinedSymbols);
231 SwapValue(Value.TOCOffset);
232 SwapValue(Value.NumTOCEntries);
233 SwapValue(Value.ModuleTableOffset);
234 SwapValue(Value.NumModuleTableEntries);
235 SwapValue(Value.ReferenceSymbolTableOffset);
236 SwapValue(Value.NumReferencedSymbolTableEntries);
237 SwapValue(Value.IndirectSymbolTableOffset);
238 SwapValue(Value.NumIndirectSymbolTableEntries);
239 SwapValue(Value.ExternalRelocationTableOffset);
240 SwapValue(Value.NumExternalRelocationTableEntries);
241 SwapValue(Value.LocalRelocationTableOffset);
242 SwapValue(Value.NumLocalRelocationTableEntries);
244 void MachOObject::ReadDysymtabLoadCommand(const LoadCommandInfo &LCI,
245 InMemoryStruct<macho::DysymtabLoadCommand> &Res) const {
246 ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
250 void SwapStruct(macho::LinkeditDataLoadCommand &Value) {
251 SwapValue(Value.Type);
252 SwapValue(Value.Size);
253 SwapValue(Value.DataOffset);
254 SwapValue(Value.DataSize);
256 void MachOObject::ReadLinkeditDataLoadCommand(const LoadCommandInfo &LCI,
257 InMemoryStruct<macho::LinkeditDataLoadCommand> &Res) const {
258 ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
262 void SwapStruct(macho::LinkerOptionsLoadCommand &Value) {
263 SwapValue(Value.Type);
264 SwapValue(Value.Size);
265 SwapValue(Value.Count);
267 void MachOObject::ReadLinkerOptionsLoadCommand(const LoadCommandInfo &LCI,
268 InMemoryStruct<macho::LinkerOptionsLoadCommand> &Res) const {
269 ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
273 void SwapStruct(macho::IndirectSymbolTableEntry &Value) {
274 SwapValue(Value.Index);
277 MachOObject::ReadIndirectSymbolTableEntry(const macho::DysymtabLoadCommand &DLC,
279 InMemoryStruct<macho::IndirectSymbolTableEntry> &Res) const {
280 uint64_t Offset = (DLC.IndirectSymbolTableOffset +
281 Index * sizeof(macho::IndirectSymbolTableEntry));
282 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
287 void SwapStruct(macho::Section &Value) {
288 SwapValue(Value.Address);
289 SwapValue(Value.Size);
290 SwapValue(Value.Offset);
291 SwapValue(Value.Align);
292 SwapValue(Value.RelocationTableOffset);
293 SwapValue(Value.NumRelocationTableEntries);
294 SwapValue(Value.Flags);
295 SwapValue(Value.Reserved1);
296 SwapValue(Value.Reserved2);
298 void MachOObject::ReadSection(const LoadCommandInfo &LCI,
300 InMemoryStruct<macho::Section> &Res) const {
301 assert(LCI.Command.Type == macho::LCT_Segment &&
302 "Unexpected load command info!");
303 uint64_t Offset = (LCI.Offset + sizeof(macho::SegmentLoadCommand) +
304 Index * sizeof(macho::Section));
305 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
309 void SwapStruct(macho::Section64 &Value) {
310 SwapValue(Value.Address);
311 SwapValue(Value.Size);
312 SwapValue(Value.Offset);
313 SwapValue(Value.Align);
314 SwapValue(Value.RelocationTableOffset);
315 SwapValue(Value.NumRelocationTableEntries);
316 SwapValue(Value.Flags);
317 SwapValue(Value.Reserved1);
318 SwapValue(Value.Reserved2);
319 SwapValue(Value.Reserved3);
321 void MachOObject::ReadSection64(const LoadCommandInfo &LCI,
323 InMemoryStruct<macho::Section64> &Res) const {
324 assert(LCI.Command.Type == macho::LCT_Segment64 &&
325 "Unexpected load command info!");
326 uint64_t Offset = (LCI.Offset + sizeof(macho::Segment64LoadCommand) +
327 Index * sizeof(macho::Section64));
328 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
332 void SwapStruct(macho::RelocationEntry &Value) {
333 SwapValue(Value.Word0);
334 SwapValue(Value.Word1);
336 void MachOObject::ReadRelocationEntry(uint64_t RelocationTableOffset,
338 InMemoryStruct<macho::RelocationEntry> &Res) const {
339 uint64_t Offset = (RelocationTableOffset +
340 Index * sizeof(macho::RelocationEntry));
341 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
345 void SwapStruct(macho::SymbolTableEntry &Value) {
346 SwapValue(Value.StringIndex);
347 SwapValue(Value.Flags);
348 SwapValue(Value.Value);
350 void MachOObject::ReadSymbolTableEntry(uint64_t SymbolTableOffset,
352 InMemoryStruct<macho::SymbolTableEntry> &Res) const {
353 uint64_t Offset = (SymbolTableOffset +
354 Index * sizeof(macho::SymbolTableEntry));
355 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
359 void SwapStruct(macho::Symbol64TableEntry &Value) {
360 SwapValue(Value.StringIndex);
361 SwapValue(Value.Flags);
362 SwapValue(Value.Value);
364 void MachOObject::ReadSymbol64TableEntry(uint64_t SymbolTableOffset,
366 InMemoryStruct<macho::Symbol64TableEntry> &Res) const {
367 uint64_t Offset = (SymbolTableOffset +
368 Index * sizeof(macho::Symbol64TableEntry));
369 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
373 void SwapStruct(macho::DataInCodeTableEntry &Value) {
374 SwapValue(Value.Offset);
375 SwapValue(Value.Length);
376 SwapValue(Value.Kind);
378 void MachOObject::ReadDataInCodeTableEntry(uint64_t TableOffset,
380 InMemoryStruct<macho::DataInCodeTableEntry> &Res) const {
381 uint64_t Offset = (TableOffset +
382 Index * sizeof(macho::DataInCodeTableEntry));
383 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
386 void MachOObject::ReadULEB128s(uint64_t Index,
387 SmallVectorImpl<uint64_t> &Out) const {
388 DataExtractor extractor(Buffer->getBuffer(), true, 0);
390 uint32_t offset = Index;
392 while (uint64_t delta = extractor.getULEB128(&offset)) {
399 // Object Dumping Facilities
400 void MachOObject::dump() const { print(dbgs()); dbgs() << '\n'; }
401 void MachOObject::dumpHeader() const { printHeader(dbgs()); dbgs() << '\n'; }
403 void MachOObject::printHeader(raw_ostream &O) const {
404 O << "('cputype', " << Header.CPUType << ")\n";
405 O << "('cpusubtype', " << Header.CPUSubtype << ")\n";
406 O << "('filetype', " << Header.FileType << ")\n";
407 O << "('num_load_commands', " << Header.NumLoadCommands << ")\n";
408 O << "('load_commands_size', " << Header.SizeOfLoadCommands << ")\n";
409 O << "('flag', " << Header.Flags << ")\n";
411 // Print extended header if 64-bit.
413 O << "('reserved', " << Header64Ext.Reserved << ")\n";
416 void MachOObject::print(raw_ostream &O) const {
419 O << "Load Commands:\n";