1 //===- MachOObject.cpp - Mach-O Object File Wrapper -----------------------===//
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 "llvm/Object/MachOObject.h"
11 #include "llvm/ADT/StringRef.h"
12 #include "llvm/ADT/SmallVector.h"
13 #include "llvm/Support/MemoryBuffer.h"
14 #include "llvm/Support/Host.h"
15 #include "llvm/Support/SwapByteOrder.h"
16 #include "llvm/Support/raw_ostream.h"
17 #include "llvm/Support/Debug.h"
18
19 using namespace llvm;
20 using namespace llvm::object;
21
22 /* Translation Utilities */
23
24 template<typename T>
SwapValue(T & Value)25 static void SwapValue(T &Value) {
26 Value = sys::SwapByteOrder(Value);
27 }
28
29 template<typename T>
30 static void SwapStruct(T &Value);
31
32 template<typename T>
ReadInMemoryStruct(const MachOObject & MOO,StringRef Buffer,uint64_t Base,InMemoryStruct<T> & Res)33 static void ReadInMemoryStruct(const MachOObject &MOO,
34 StringRef Buffer, uint64_t Base,
35 InMemoryStruct<T> &Res) {
36 typedef T struct_type;
37 uint64_t Size = sizeof(struct_type);
38
39 // Check that the buffer contains the expected data.
40 if (Base + Size > Buffer.size()) {
41 Res = 0;
42 return;
43 }
44
45 // Check whether we can return a direct pointer.
46 struct_type *Ptr = (struct_type *) (Buffer.data() + Base);
47 if (!MOO.isSwappedEndian()) {
48 Res = Ptr;
49 return;
50 }
51
52 // Otherwise, copy the struct and translate the values.
53 Res = *Ptr;
54 SwapStruct(*Res);
55 }
56
57 /* *** */
58
MachOObject(MemoryBuffer * Buffer_,bool IsLittleEndian_,bool Is64Bit_)59 MachOObject::MachOObject(MemoryBuffer *Buffer_, bool IsLittleEndian_,
60 bool Is64Bit_)
61 : Buffer(Buffer_), IsLittleEndian(IsLittleEndian_), Is64Bit(Is64Bit_),
62 IsSwappedEndian(IsLittleEndian != sys::isLittleEndianHost()),
63 HasStringTable(false), LoadCommands(0), NumLoadedCommands(0) {
64 // Load the common header.
65 memcpy(&Header, Buffer->getBuffer().data(), sizeof(Header));
66 if (IsSwappedEndian) {
67 SwapValue(Header.Magic);
68 SwapValue(Header.CPUType);
69 SwapValue(Header.CPUSubtype);
70 SwapValue(Header.FileType);
71 SwapValue(Header.NumLoadCommands);
72 SwapValue(Header.SizeOfLoadCommands);
73 SwapValue(Header.Flags);
74 }
75
76 if (is64Bit()) {
77 memcpy(&Header64Ext, Buffer->getBuffer().data() + sizeof(Header),
78 sizeof(Header64Ext));
79 if (IsSwappedEndian) {
80 SwapValue(Header64Ext.Reserved);
81 }
82 }
83
84 // Create the load command array if sane.
85 if (getHeader().NumLoadCommands < (1 << 20))
86 LoadCommands = new LoadCommandInfo[getHeader().NumLoadCommands];
87 }
88
~MachOObject()89 MachOObject::~MachOObject() {
90 delete [] LoadCommands;
91 }
92
LoadFromBuffer(MemoryBuffer * Buffer,std::string * ErrorStr)93 MachOObject *MachOObject::LoadFromBuffer(MemoryBuffer *Buffer,
94 std::string *ErrorStr) {
95 // First, check the magic value and initialize the basic object info.
96 bool IsLittleEndian = false, Is64Bit = false;
97 StringRef Magic = Buffer->getBuffer().slice(0, 4);
98 if (Magic == "\xFE\xED\xFA\xCE") {
99 } else if (Magic == "\xCE\xFA\xED\xFE") {
100 IsLittleEndian = true;
101 } else if (Magic == "\xFE\xED\xFA\xCF") {
102 Is64Bit = true;
103 } else if (Magic == "\xCF\xFA\xED\xFE") {
104 IsLittleEndian = true;
105 Is64Bit = true;
106 } else {
107 if (ErrorStr) *ErrorStr = "not a Mach object file (invalid magic)";
108 return 0;
109 }
110
111 // Ensure that the at least the full header is present.
112 unsigned HeaderSize = Is64Bit ? macho::Header64Size : macho::Header32Size;
113 if (Buffer->getBufferSize() < HeaderSize) {
114 if (ErrorStr) *ErrorStr = "not a Mach object file (invalid header)";
115 return 0;
116 }
117
118 OwningPtr<MachOObject> Object(new MachOObject(Buffer, IsLittleEndian,
119 Is64Bit));
120
121 // Check for bogus number of load commands.
122 if (Object->getHeader().NumLoadCommands >= (1 << 20)) {
123 if (ErrorStr) *ErrorStr = "not a Mach object file (unreasonable header)";
124 return 0;
125 }
126
127 if (ErrorStr) *ErrorStr = "";
128 return Object.take();
129 }
130
getData(size_t Offset,size_t Size) const131 StringRef MachOObject::getData(size_t Offset, size_t Size) const {
132 return Buffer->getBuffer().substr(Offset,Size);
133 }
134
RegisterStringTable(macho::SymtabLoadCommand & SLC)135 void MachOObject::RegisterStringTable(macho::SymtabLoadCommand &SLC) {
136 HasStringTable = true;
137 StringTable = Buffer->getBuffer().substr(SLC.StringTableOffset,
138 SLC.StringTableSize);
139 }
140
141 const MachOObject::LoadCommandInfo &
getLoadCommandInfo(unsigned Index) const142 MachOObject::getLoadCommandInfo(unsigned Index) const {
143 assert(Index < getHeader().NumLoadCommands && "Invalid index!");
144
145 // Load the command, if necessary.
146 if (Index >= NumLoadedCommands) {
147 uint64_t Offset;
148 if (Index == 0) {
149 Offset = getHeaderSize();
150 } else {
151 const LoadCommandInfo &Prev = getLoadCommandInfo(Index - 1);
152 Offset = Prev.Offset + Prev.Command.Size;
153 }
154
155 LoadCommandInfo &Info = LoadCommands[Index];
156 memcpy(&Info.Command, Buffer->getBuffer().data() + Offset,
157 sizeof(macho::LoadCommand));
158 if (IsSwappedEndian) {
159 SwapValue(Info.Command.Type);
160 SwapValue(Info.Command.Size);
161 }
162 Info.Offset = Offset;
163 NumLoadedCommands = Index + 1;
164 }
165
166 return LoadCommands[Index];
167 }
168
169 template<>
SwapStruct(macho::SegmentLoadCommand & Value)170 void SwapStruct(macho::SegmentLoadCommand &Value) {
171 SwapValue(Value.Type);
172 SwapValue(Value.Size);
173 SwapValue(Value.VMAddress);
174 SwapValue(Value.VMSize);
175 SwapValue(Value.FileOffset);
176 SwapValue(Value.FileSize);
177 SwapValue(Value.MaxVMProtection);
178 SwapValue(Value.InitialVMProtection);
179 SwapValue(Value.NumSections);
180 SwapValue(Value.Flags);
181 }
ReadSegmentLoadCommand(const LoadCommandInfo & LCI,InMemoryStruct<macho::SegmentLoadCommand> & Res) const182 void MachOObject::ReadSegmentLoadCommand(const LoadCommandInfo &LCI,
183 InMemoryStruct<macho::SegmentLoadCommand> &Res) const {
184 ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
185 }
186
187 template<>
SwapStruct(macho::Segment64LoadCommand & Value)188 void SwapStruct(macho::Segment64LoadCommand &Value) {
189 SwapValue(Value.Type);
190 SwapValue(Value.Size);
191 SwapValue(Value.VMAddress);
192 SwapValue(Value.VMSize);
193 SwapValue(Value.FileOffset);
194 SwapValue(Value.FileSize);
195 SwapValue(Value.MaxVMProtection);
196 SwapValue(Value.InitialVMProtection);
197 SwapValue(Value.NumSections);
198 SwapValue(Value.Flags);
199 }
ReadSegment64LoadCommand(const LoadCommandInfo & LCI,InMemoryStruct<macho::Segment64LoadCommand> & Res) const200 void MachOObject::ReadSegment64LoadCommand(const LoadCommandInfo &LCI,
201 InMemoryStruct<macho::Segment64LoadCommand> &Res) const {
202 ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
203 }
204
205 template<>
SwapStruct(macho::SymtabLoadCommand & Value)206 void SwapStruct(macho::SymtabLoadCommand &Value) {
207 SwapValue(Value.Type);
208 SwapValue(Value.Size);
209 SwapValue(Value.SymbolTableOffset);
210 SwapValue(Value.NumSymbolTableEntries);
211 SwapValue(Value.StringTableOffset);
212 SwapValue(Value.StringTableSize);
213 }
ReadSymtabLoadCommand(const LoadCommandInfo & LCI,InMemoryStruct<macho::SymtabLoadCommand> & Res) const214 void MachOObject::ReadSymtabLoadCommand(const LoadCommandInfo &LCI,
215 InMemoryStruct<macho::SymtabLoadCommand> &Res) const {
216 ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
217 }
218
219 template<>
SwapStruct(macho::DysymtabLoadCommand & Value)220 void SwapStruct(macho::DysymtabLoadCommand &Value) {
221 SwapValue(Value.Type);
222 SwapValue(Value.Size);
223 SwapValue(Value.LocalSymbolsIndex);
224 SwapValue(Value.NumLocalSymbols);
225 SwapValue(Value.ExternalSymbolsIndex);
226 SwapValue(Value.NumExternalSymbols);
227 SwapValue(Value.UndefinedSymbolsIndex);
228 SwapValue(Value.NumUndefinedSymbols);
229 SwapValue(Value.TOCOffset);
230 SwapValue(Value.NumTOCEntries);
231 SwapValue(Value.ModuleTableOffset);
232 SwapValue(Value.NumModuleTableEntries);
233 SwapValue(Value.ReferenceSymbolTableOffset);
234 SwapValue(Value.NumReferencedSymbolTableEntries);
235 SwapValue(Value.IndirectSymbolTableOffset);
236 SwapValue(Value.NumIndirectSymbolTableEntries);
237 SwapValue(Value.ExternalRelocationTableOffset);
238 SwapValue(Value.NumExternalRelocationTableEntries);
239 SwapValue(Value.LocalRelocationTableOffset);
240 SwapValue(Value.NumLocalRelocationTableEntries);
241 }
ReadDysymtabLoadCommand(const LoadCommandInfo & LCI,InMemoryStruct<macho::DysymtabLoadCommand> & Res) const242 void MachOObject::ReadDysymtabLoadCommand(const LoadCommandInfo &LCI,
243 InMemoryStruct<macho::DysymtabLoadCommand> &Res) const {
244 ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
245 }
246
247 template<>
SwapStruct(macho::LinkeditDataLoadCommand & Value)248 void SwapStruct(macho::LinkeditDataLoadCommand &Value) {
249 SwapValue(Value.Type);
250 SwapValue(Value.Size);
251 SwapValue(Value.DataOffset);
252 SwapValue(Value.DataSize);
253 }
ReadLinkeditDataLoadCommand(const LoadCommandInfo & LCI,InMemoryStruct<macho::LinkeditDataLoadCommand> & Res) const254 void MachOObject::ReadLinkeditDataLoadCommand(const LoadCommandInfo &LCI,
255 InMemoryStruct<macho::LinkeditDataLoadCommand> &Res) const {
256 ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
257 }
258
259 template<>
SwapStruct(macho::IndirectSymbolTableEntry & Value)260 void SwapStruct(macho::IndirectSymbolTableEntry &Value) {
261 SwapValue(Value.Index);
262 }
263 void
ReadIndirectSymbolTableEntry(const macho::DysymtabLoadCommand & DLC,unsigned Index,InMemoryStruct<macho::IndirectSymbolTableEntry> & Res) const264 MachOObject::ReadIndirectSymbolTableEntry(const macho::DysymtabLoadCommand &DLC,
265 unsigned Index,
266 InMemoryStruct<macho::IndirectSymbolTableEntry> &Res) const {
267 uint64_t Offset = (DLC.IndirectSymbolTableOffset +
268 Index * sizeof(macho::IndirectSymbolTableEntry));
269 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
270 }
271
272
273 template<>
SwapStruct(macho::Section & Value)274 void SwapStruct(macho::Section &Value) {
275 SwapValue(Value.Address);
276 SwapValue(Value.Size);
277 SwapValue(Value.Offset);
278 SwapValue(Value.Align);
279 SwapValue(Value.RelocationTableOffset);
280 SwapValue(Value.NumRelocationTableEntries);
281 SwapValue(Value.Flags);
282 SwapValue(Value.Reserved1);
283 SwapValue(Value.Reserved2);
284 }
ReadSection(const LoadCommandInfo & LCI,unsigned Index,InMemoryStruct<macho::Section> & Res) const285 void MachOObject::ReadSection(const LoadCommandInfo &LCI,
286 unsigned Index,
287 InMemoryStruct<macho::Section> &Res) const {
288 assert(LCI.Command.Type == macho::LCT_Segment &&
289 "Unexpected load command info!");
290 uint64_t Offset = (LCI.Offset + sizeof(macho::SegmentLoadCommand) +
291 Index * sizeof(macho::Section));
292 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
293 }
294
295 template<>
SwapStruct(macho::Section64 & Value)296 void SwapStruct(macho::Section64 &Value) {
297 SwapValue(Value.Address);
298 SwapValue(Value.Size);
299 SwapValue(Value.Offset);
300 SwapValue(Value.Align);
301 SwapValue(Value.RelocationTableOffset);
302 SwapValue(Value.NumRelocationTableEntries);
303 SwapValue(Value.Flags);
304 SwapValue(Value.Reserved1);
305 SwapValue(Value.Reserved2);
306 SwapValue(Value.Reserved3);
307 }
ReadSection64(const LoadCommandInfo & LCI,unsigned Index,InMemoryStruct<macho::Section64> & Res) const308 void MachOObject::ReadSection64(const LoadCommandInfo &LCI,
309 unsigned Index,
310 InMemoryStruct<macho::Section64> &Res) const {
311 assert(LCI.Command.Type == macho::LCT_Segment64 &&
312 "Unexpected load command info!");
313 uint64_t Offset = (LCI.Offset + sizeof(macho::Segment64LoadCommand) +
314 Index * sizeof(macho::Section64));
315 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
316 }
317
318 template<>
SwapStruct(macho::RelocationEntry & Value)319 void SwapStruct(macho::RelocationEntry &Value) {
320 SwapValue(Value.Word0);
321 SwapValue(Value.Word1);
322 }
ReadRelocationEntry(uint64_t RelocationTableOffset,unsigned Index,InMemoryStruct<macho::RelocationEntry> & Res) const323 void MachOObject::ReadRelocationEntry(uint64_t RelocationTableOffset,
324 unsigned Index,
325 InMemoryStruct<macho::RelocationEntry> &Res) const {
326 uint64_t Offset = (RelocationTableOffset +
327 Index * sizeof(macho::RelocationEntry));
328 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
329 }
330
331 template<>
SwapStruct(macho::SymbolTableEntry & Value)332 void SwapStruct(macho::SymbolTableEntry &Value) {
333 SwapValue(Value.StringIndex);
334 SwapValue(Value.Flags);
335 SwapValue(Value.Value);
336 }
ReadSymbolTableEntry(uint64_t SymbolTableOffset,unsigned Index,InMemoryStruct<macho::SymbolTableEntry> & Res) const337 void MachOObject::ReadSymbolTableEntry(uint64_t SymbolTableOffset,
338 unsigned Index,
339 InMemoryStruct<macho::SymbolTableEntry> &Res) const {
340 uint64_t Offset = (SymbolTableOffset +
341 Index * sizeof(macho::SymbolTableEntry));
342 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
343 }
344
345 template<>
SwapStruct(macho::Symbol64TableEntry & Value)346 void SwapStruct(macho::Symbol64TableEntry &Value) {
347 SwapValue(Value.StringIndex);
348 SwapValue(Value.Flags);
349 SwapValue(Value.Value);
350 }
ReadSymbol64TableEntry(uint64_t SymbolTableOffset,unsigned Index,InMemoryStruct<macho::Symbol64TableEntry> & Res) const351 void MachOObject::ReadSymbol64TableEntry(uint64_t SymbolTableOffset,
352 unsigned Index,
353 InMemoryStruct<macho::Symbol64TableEntry> &Res) const {
354 uint64_t Offset = (SymbolTableOffset +
355 Index * sizeof(macho::Symbol64TableEntry));
356 ReadInMemoryStruct(*this, Buffer->getBuffer(), Offset, Res);
357 }
358
359
ReadULEB128s(uint64_t Index,SmallVectorImpl<uint64_t> & Out) const360 void MachOObject::ReadULEB128s(uint64_t Index,
361 SmallVectorImpl<uint64_t> &Out) const {
362 const char *ptr = Buffer->getBufferStart() + Index;
363 uint64_t data = 0;
364 uint64_t delta = 0;
365 uint32_t shift = 0;
366 while (true) {
367 assert(ptr < Buffer->getBufferEnd() && "index out of bounds");
368 assert(shift < 64 && "too big for uint64_t");
369
370 uint8_t byte = *ptr++;
371 delta |= ((byte & 0x7F) << shift);
372 shift += 7;
373 if (byte < 0x80) {
374 if (delta == 0)
375 break;
376 data += delta;
377 Out.push_back(data);
378 delta = 0;
379 shift = 0;
380 }
381 }
382 }
383
384 /* ** */
385 // Object Dumping Facilities
dump() const386 void MachOObject::dump() const { print(dbgs()); dbgs() << '\n'; }
dumpHeader() const387 void MachOObject::dumpHeader() const { printHeader(dbgs()); dbgs() << '\n'; }
388
printHeader(raw_ostream & O) const389 void MachOObject::printHeader(raw_ostream &O) const {
390 O << "('cputype', " << Header.CPUType << ")\n";
391 O << "('cpusubtype', " << Header.CPUSubtype << ")\n";
392 O << "('filetype', " << Header.FileType << ")\n";
393 O << "('num_load_commands', " << Header.NumLoadCommands << ")\n";
394 O << "('load_commands_size', " << Header.SizeOfLoadCommands << ")\n";
395 O << "('flag', " << Header.Flags << ")\n";
396
397 // Print extended header if 64-bit.
398 if (is64Bit())
399 O << "('reserved', " << Header64Ext.Reserved << ")\n";
400 }
401
print(raw_ostream & O) const402 void MachOObject::print(raw_ostream &O) const {
403 O << "Header:\n";
404 printHeader(O);
405 O << "Load Commands:\n";
406
407 O << "Buffer:\n";
408 }
409