MachOObject.cpp revision d4522460d495fb0be3303f0727f9bd00867c0b16 
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
19using namespace llvm;
20using namespace llvm::object;
21
22/* Translation Utilities */
23
24template<typename T>
25static void SwapValue(T &Value) {
26  Value = sys::SwapByteOrder(Value);
27}
28
29template<typename T>
30static void SwapStruct(T &Value);
31
32template<typename T>
33static 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
59MachOObject::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
89MachOObject::~MachOObject() {
90  delete [] LoadCommands;
91}
92
93MachOObject *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
131StringRef MachOObject::getData(size_t Offset, size_t Size) const {
132  return Buffer->getBuffer().substr(Offset,Size);
133}
134
135void MachOObject::RegisterStringTable(macho::SymtabLoadCommand &SLC) {
136  HasStringTable = true;
137  StringTable = Buffer->getBuffer().substr(SLC.StringTableOffset,
138                                           SLC.StringTableSize);
139}
140
141const MachOObject::LoadCommandInfo &
142MachOObject::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
169template<>
170void 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}
182void MachOObject::ReadSegmentLoadCommand(const LoadCommandInfo &LCI,
183                         InMemoryStruct<macho::SegmentLoadCommand> &Res) const {
184  ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
185}
186
187template<>
188void 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}
200void MachOObject::ReadSegment64LoadCommand(const LoadCommandInfo &LCI,
201                       InMemoryStruct<macho::Segment64LoadCommand> &Res) const {
202  ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
203}
204
205template<>
206void 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}
214void MachOObject::ReadSymtabLoadCommand(const LoadCommandInfo &LCI,
215                          InMemoryStruct<macho::SymtabLoadCommand> &Res) const {
216  ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
217}
218
219template<>
220void 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}
242void MachOObject::ReadDysymtabLoadCommand(const LoadCommandInfo &LCI,
243                        InMemoryStruct<macho::DysymtabLoadCommand> &Res) const {
244  ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
245}
246
247template<>
248void SwapStruct(macho::LinkeditDataLoadCommand &Value) {
249  SwapValue(Value.Type);
250  SwapValue(Value.Size);
251  SwapValue(Value.DataOffset);
252  SwapValue(Value.DataSize);
253}
254void MachOObject::ReadLinkeditDataLoadCommand(const LoadCommandInfo &LCI,
255                    InMemoryStruct<macho::LinkeditDataLoadCommand> &Res) const {
256  ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
257}
258
259template<>
260void SwapStruct(macho::IndirectSymbolTableEntry &Value) {
261  SwapValue(Value.Index);
262}
263void
264MachOObject::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
273template<>
274void 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}
285void 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
295template<>
296void 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}
308void 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
318template<>
319void SwapStruct(macho::RelocationEntry &Value) {
320  SwapValue(Value.Word0);
321  SwapValue(Value.Word1);
322}
323void 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
331template<>
332void SwapStruct(macho::SymbolTableEntry &Value) {
333  SwapValue(Value.StringIndex);
334  SwapValue(Value.Flags);
335  SwapValue(Value.Value);
336}
337void 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
345template<>
346void SwapStruct(macho::Symbol64TableEntry &Value) {
347  SwapValue(Value.StringIndex);
348  SwapValue(Value.Flags);
349  SwapValue(Value.Value);
350}
351void 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
360void 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
386void MachOObject::dump() const { print(dbgs()); dbgs() << '\n'; }
387void MachOObject::dumpHeader() const { printHeader(dbgs()); dbgs() << '\n'; }
388
389void 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
402void 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