2011-04-22 11:19:48 +08:00
|
|
|
//===- MachOObjectFile.cpp - Mach-O object file binding ---------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file defines the MachOObjectFile class, which binds the MachOObject
|
|
|
|
// class to the generic ObjectFile wrapper.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2011-10-12 01:32:27 +08:00
|
|
|
#include "llvm/Object/MachO.h"
|
2014-03-29 18:18:08 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2014-08-09 00:30:17 +08:00
|
|
|
#include "llvm/ADT/StringSwitch.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2013-04-08 04:01:29 +08:00
|
|
|
#include "llvm/Support/DataExtractor.h"
|
2014-09-13 05:34:15 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
2011-10-27 04:42:54 +08:00
|
|
|
#include "llvm/Support/Format.h"
|
2013-04-19 02:08:55 +08:00
|
|
|
#include "llvm/Support/Host.h"
|
2014-08-30 08:20:14 +08:00
|
|
|
#include "llvm/Support/LEB128.h"
|
|
|
|
#include "llvm/Support/MachO.h"
|
2011-04-22 11:19:48 +08:00
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
2013-08-21 09:20:11 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2011-04-22 11:19:48 +08:00
|
|
|
#include <cctype>
|
|
|
|
#include <cstring>
|
|
|
|
#include <limits>
|
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
using namespace object;
|
|
|
|
|
2014-07-20 20:08:28 +08:00
|
|
|
namespace {
|
|
|
|
struct section_base {
|
|
|
|
char sectname[16];
|
|
|
|
char segname[16];
|
|
|
|
};
|
|
|
|
}
|
2013-04-19 02:08:55 +08:00
|
|
|
|
2016-03-26 01:25:34 +08:00
|
|
|
static Error
|
2016-05-06 07:41:05 +08:00
|
|
|
malformedError(const MachOObjectFile &Obj, Twine Msg) {
|
|
|
|
std::string StringMsg = "truncated or malformed object (" + Msg.str() + ")";
|
2016-05-06 07:59:57 +08:00
|
|
|
return make_error<GenericBinaryError>(Obj.getFileName(), std::move(StringMsg),
|
2016-05-06 07:41:05 +08:00
|
|
|
object_error::parse_failed);
|
2016-03-26 01:25:34 +08:00
|
|
|
}
|
|
|
|
|
2015-06-05 03:45:22 +08:00
|
|
|
// FIXME: Replace all uses of this function with getStructOrErr.
|
2015-01-16 06:52:38 +08:00
|
|
|
template <typename T>
|
2014-07-20 20:08:28 +08:00
|
|
|
static T getStruct(const MachOObjectFile *O, const char *P) {
|
2015-01-16 06:52:38 +08:00
|
|
|
// Don't read before the beginning or past the end of the file
|
|
|
|
if (P < O->getData().begin() || P + sizeof(T) > O->getData().end())
|
|
|
|
report_fatal_error("Malformed MachO file.");
|
|
|
|
|
2013-04-19 21:45:05 +08:00
|
|
|
T Cmd;
|
|
|
|
memcpy(&Cmd, P, sizeof(T));
|
|
|
|
if (O->isLittleEndian() != sys::IsLittleEndianHost)
|
2014-07-18 17:26:16 +08:00
|
|
|
MachO::swapStruct(Cmd);
|
2013-04-19 21:45:05 +08:00
|
|
|
return Cmd;
|
2012-03-01 09:36:50 +08:00
|
|
|
}
|
|
|
|
|
2015-06-05 03:45:22 +08:00
|
|
|
template <typename T>
|
2016-03-26 01:25:34 +08:00
|
|
|
static Expected<T> getStructOrErr(const MachOObjectFile *O, const char *P) {
|
2015-06-05 03:45:22 +08:00
|
|
|
// Don't read before the beginning or past the end of the file
|
|
|
|
if (P < O->getData().begin() || P + sizeof(T) > O->getData().end())
|
2016-03-26 01:25:34 +08:00
|
|
|
return malformedError(*O, "Structure read out-of-range");
|
2015-06-05 03:45:22 +08:00
|
|
|
|
|
|
|
T Cmd;
|
|
|
|
memcpy(&Cmd, P, sizeof(T));
|
|
|
|
if (O->isLittleEndian() != sys::IsLittleEndianHost)
|
|
|
|
MachO::swapStruct(Cmd);
|
|
|
|
return Cmd;
|
|
|
|
}
|
|
|
|
|
2013-04-27 04:07:33 +08:00
|
|
|
static const char *
|
|
|
|
getSectionPtr(const MachOObjectFile *O, MachOObjectFile::LoadCommandInfo L,
|
|
|
|
unsigned Sec) {
|
2013-04-19 02:08:55 +08:00
|
|
|
uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(L.Ptr);
|
2011-04-22 11:19:48 +08:00
|
|
|
|
2013-04-19 02:08:55 +08:00
|
|
|
bool Is64 = O->is64Bit();
|
2013-09-01 12:28:48 +08:00
|
|
|
unsigned SegmentLoadSize = Is64 ? sizeof(MachO::segment_command_64) :
|
|
|
|
sizeof(MachO::segment_command);
|
|
|
|
unsigned SectionSize = Is64 ? sizeof(MachO::section_64) :
|
|
|
|
sizeof(MachO::section);
|
2013-04-19 02:08:55 +08:00
|
|
|
|
|
|
|
uintptr_t SectionAddr = CommandAddr + SegmentLoadSize + Sec * SectionSize;
|
2013-08-27 13:38:30 +08:00
|
|
|
return reinterpret_cast<const char*>(SectionAddr);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char *getPtr(const MachOObjectFile *O, size_t Offset) {
|
|
|
|
return O->getData().substr(Offset, 1).data();
|
|
|
|
}
|
|
|
|
|
2014-07-18 17:26:16 +08:00
|
|
|
static MachO::nlist_base
|
2013-04-19 02:08:55 +08:00
|
|
|
getSymbolTableEntryBase(const MachOObjectFile *O, DataRefImpl DRI) {
|
2013-04-25 03:47:55 +08:00
|
|
|
const char *P = reinterpret_cast<const char *>(DRI.p);
|
2014-07-18 17:26:16 +08:00
|
|
|
return getStruct<MachO::nlist_base>(O, P);
|
2011-10-08 03:25:32 +08:00
|
|
|
}
|
|
|
|
|
2013-04-19 02:08:55 +08:00
|
|
|
static StringRef parseSegmentOrSectionName(const char *P) {
|
Add a function to get the segment name of a section.
On MachO, sections also have segment names. When a tool looking at a .o file
prints a segment name, this is what they mean. In reality, a .o has only one
anonymous, segment.
This patch adds a MachO only function to fetch that segment name. I named it
getSectionFinalSegmentName since the main use for the name seems to be inform
the linker with segment this section should go to.
The patch also changes MachOObjectFile::getSectionName to return just the
section name instead of computing SegmentName,SectionName.
The main difference from the previous patch is that it doesn't use
InMemoryStruct. It is extremely dangerous: if the endians match it returns
a pointer to the file buffer, if not, it returns a pointer to an internal buffer
that is overwritten in the next API call.
We should change all of this code to use
support::detail::packed_endian_specific_integral like ELF, but since these
functions only handle strings, they work with big and little endian machines
as is.
I have tested this by installing ubuntu 12.10 ppc on qemu, that is why it took
so long :-)
llvm-svn: 170838
2012-12-21 11:47:03 +08:00
|
|
|
if (P[15] == 0)
|
|
|
|
// Null terminated.
|
|
|
|
return P;
|
|
|
|
// Not null terminated, so this is a 16 char string.
|
|
|
|
return StringRef(P, 16);
|
|
|
|
}
|
|
|
|
|
2013-04-19 02:08:55 +08:00
|
|
|
// Helper to advance a section or symbol iterator multiple increments at a time.
|
|
|
|
template<class T>
|
2014-01-30 10:49:50 +08:00
|
|
|
static void advance(T &it, size_t Val) {
|
|
|
|
while (Val--)
|
|
|
|
++it;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned getCPUType(const MachOObjectFile *O) {
|
2013-09-01 12:28:48 +08:00
|
|
|
return O->getHeader().cputype;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
static uint32_t
|
|
|
|
getPlainRelocationAddress(const MachO::any_relocation_info &RE) {
|
|
|
|
return RE.r_word0;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned
|
2013-09-01 12:28:48 +08:00
|
|
|
getScatteredRelocationAddress(const MachO::any_relocation_info &RE) {
|
|
|
|
return RE.r_word0 & 0xffffff;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool getPlainRelocationPCRel(const MachOObjectFile *O,
|
2013-09-01 12:28:48 +08:00
|
|
|
const MachO::any_relocation_info &RE) {
|
2013-04-19 02:08:55 +08:00
|
|
|
if (O->isLittleEndian())
|
2013-09-01 12:28:48 +08:00
|
|
|
return (RE.r_word1 >> 24) & 1;
|
|
|
|
return (RE.r_word1 >> 7) & 1;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
getScatteredRelocationPCRel(const MachOObjectFile *O,
|
2013-09-01 12:28:48 +08:00
|
|
|
const MachO::any_relocation_info &RE) {
|
|
|
|
return (RE.r_word0 >> 30) & 1;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned getPlainRelocationLength(const MachOObjectFile *O,
|
2013-09-01 12:28:48 +08:00
|
|
|
const MachO::any_relocation_info &RE) {
|
2013-04-19 02:08:55 +08:00
|
|
|
if (O->isLittleEndian())
|
2013-09-01 12:28:48 +08:00
|
|
|
return (RE.r_word1 >> 25) & 3;
|
|
|
|
return (RE.r_word1 >> 5) & 3;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned
|
2013-09-01 12:28:48 +08:00
|
|
|
getScatteredRelocationLength(const MachO::any_relocation_info &RE) {
|
|
|
|
return (RE.r_word0 >> 28) & 3;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned getPlainRelocationType(const MachOObjectFile *O,
|
2013-09-01 12:28:48 +08:00
|
|
|
const MachO::any_relocation_info &RE) {
|
2013-04-19 02:08:55 +08:00
|
|
|
if (O->isLittleEndian())
|
2013-09-01 12:28:48 +08:00
|
|
|
return RE.r_word1 >> 28;
|
|
|
|
return RE.r_word1 & 0xf;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t getSectionFlags(const MachOObjectFile *O,
|
|
|
|
DataRefImpl Sec) {
|
|
|
|
if (O->is64Bit()) {
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::section_64 Sect = O->getSection64(Sec);
|
|
|
|
return Sect.flags;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::section Sect = O->getSection(Sec);
|
|
|
|
return Sect.flags;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2016-03-26 01:25:34 +08:00
|
|
|
static Expected<MachOObjectFile::LoadCommandInfo>
|
2016-05-04 07:13:50 +08:00
|
|
|
getLoadCommandInfo(const MachOObjectFile *Obj, const char *Ptr,
|
|
|
|
uint32_t LoadCommandIndex) {
|
2016-03-26 01:25:34 +08:00
|
|
|
if (auto CmdOrErr = getStructOrErr<MachO::load_command>(Obj, Ptr)) {
|
|
|
|
if (CmdOrErr->cmdsize < 8)
|
2016-05-06 07:41:05 +08:00
|
|
|
return malformedError(*Obj, "load command " + Twine(LoadCommandIndex) +
|
|
|
|
" with size less than 8 bytes");
|
2016-03-26 01:25:34 +08:00
|
|
|
return MachOObjectFile::LoadCommandInfo({Ptr, *CmdOrErr});
|
|
|
|
} else
|
|
|
|
return CmdOrErr.takeError();
|
|
|
|
}
|
|
|
|
|
|
|
|
static Expected<MachOObjectFile::LoadCommandInfo>
|
2015-06-05 03:34:14 +08:00
|
|
|
getFirstLoadCommandInfo(const MachOObjectFile *Obj) {
|
|
|
|
unsigned HeaderSize = Obj->is64Bit() ? sizeof(MachO::mach_header_64)
|
|
|
|
: sizeof(MachO::mach_header);
|
2016-04-07 06:14:09 +08:00
|
|
|
if (sizeof(MachOObjectFile::LoadCommandInfo) > Obj->getHeader().sizeofcmds)
|
2016-05-06 07:41:05 +08:00
|
|
|
return malformedError(*Obj, "load command 0 extends past the end all load "
|
|
|
|
"commands in the file");
|
2016-05-04 07:13:50 +08:00
|
|
|
return getLoadCommandInfo(Obj, getPtr(Obj, HeaderSize), 0);
|
2015-06-05 03:34:14 +08:00
|
|
|
}
|
|
|
|
|
2016-03-26 01:25:34 +08:00
|
|
|
static Expected<MachOObjectFile::LoadCommandInfo>
|
2016-05-04 01:16:08 +08:00
|
|
|
getNextLoadCommandInfo(const MachOObjectFile *Obj, uint32_t LoadCommandIndex,
|
2015-06-05 03:34:14 +08:00
|
|
|
const MachOObjectFile::LoadCommandInfo &L) {
|
2016-05-04 01:16:08 +08:00
|
|
|
unsigned HeaderSize = Obj->is64Bit() ? sizeof(MachO::mach_header_64)
|
|
|
|
: sizeof(MachO::mach_header);
|
|
|
|
if (L.Ptr + L.C.cmdsize + sizeof(MachOObjectFile::LoadCommandInfo) >
|
|
|
|
Obj->getData().data() + HeaderSize + Obj->getHeader().sizeofcmds)
|
2016-05-06 07:41:05 +08:00
|
|
|
return malformedError(*Obj, "load command " + Twine(LoadCommandIndex + 1) +
|
|
|
|
" extends past the end all load commands in the file");
|
2016-05-04 07:13:50 +08:00
|
|
|
return getLoadCommandInfo(Obj, L.Ptr + L.C.cmdsize, LoadCommandIndex + 1);
|
2015-06-05 03:34:14 +08:00
|
|
|
}
|
|
|
|
|
2015-06-05 03:45:22 +08:00
|
|
|
template <typename T>
|
|
|
|
static void parseHeader(const MachOObjectFile *Obj, T &Header,
|
2016-03-26 01:25:34 +08:00
|
|
|
Error &Err) {
|
2016-04-14 05:17:58 +08:00
|
|
|
if (sizeof(T) > Obj->getData().size()) {
|
2016-05-06 07:41:05 +08:00
|
|
|
Err = malformedError(*Obj, "the mach header extends past the end of the "
|
|
|
|
"file");
|
2016-04-14 05:17:58 +08:00
|
|
|
return;
|
|
|
|
}
|
2016-03-26 01:25:34 +08:00
|
|
|
if (auto HeaderOrErr = getStructOrErr<T>(Obj, getPtr(Obj, 0)))
|
|
|
|
Header = *HeaderOrErr;
|
2015-06-05 03:45:22 +08:00
|
|
|
else
|
2016-03-26 01:25:34 +08:00
|
|
|
Err = HeaderOrErr.takeError();
|
2015-06-05 03:45:22 +08:00
|
|
|
}
|
|
|
|
|
2015-06-05 06:08:37 +08:00
|
|
|
// Parses LC_SEGMENT or LC_SEGMENT_64 load command, adds addresses of all
|
|
|
|
// sections to \param Sections, and optionally sets
|
|
|
|
// \param IsPageZeroSegment to true.
|
|
|
|
template <typename SegmentCmd>
|
2016-03-26 01:25:34 +08:00
|
|
|
static Error parseSegmentLoadCommand(
|
2015-06-05 06:08:37 +08:00
|
|
|
const MachOObjectFile *Obj, const MachOObjectFile::LoadCommandInfo &Load,
|
2016-05-06 01:43:35 +08:00
|
|
|
SmallVectorImpl<const char *> &Sections, bool &IsPageZeroSegment,
|
|
|
|
uint32_t LoadCommandIndex, const char *CmdName) {
|
2015-06-05 06:08:37 +08:00
|
|
|
const unsigned SegmentLoadSize = sizeof(SegmentCmd);
|
|
|
|
if (Load.C.cmdsize < SegmentLoadSize)
|
2016-05-06 07:41:05 +08:00
|
|
|
return malformedError(*Obj, "load command " + Twine(LoadCommandIndex) +
|
|
|
|
" " + CmdName + " cmdsize too small");
|
2016-03-26 01:25:34 +08:00
|
|
|
if (auto SegOrErr = getStructOrErr<SegmentCmd>(Obj, Load.Ptr)) {
|
|
|
|
SegmentCmd S = SegOrErr.get();
|
|
|
|
const unsigned SectionSize =
|
2015-06-05 06:08:37 +08:00
|
|
|
Obj->is64Bit() ? sizeof(MachO::section_64) : sizeof(MachO::section);
|
2016-03-26 01:25:34 +08:00
|
|
|
if (S.nsects > std::numeric_limits<uint32_t>::max() / SectionSize ||
|
|
|
|
S.nsects * SectionSize > Load.C.cmdsize - SegmentLoadSize)
|
2016-05-06 07:41:05 +08:00
|
|
|
return malformedError(*Obj, "load command " + Twine(LoadCommandIndex) +
|
|
|
|
" inconsistent cmdsize in " + CmdName +
|
|
|
|
" for the number of sections");
|
2016-03-26 01:25:34 +08:00
|
|
|
for (unsigned J = 0; J < S.nsects; ++J) {
|
|
|
|
const char *Sec = getSectionPtr(Obj, Load, J);
|
|
|
|
Sections.push_back(Sec);
|
|
|
|
}
|
|
|
|
IsPageZeroSegment |= StringRef("__PAGEZERO").equals(S.segname);
|
|
|
|
} else
|
|
|
|
return SegOrErr.takeError();
|
|
|
|
|
|
|
|
return Error::success();
|
2015-06-05 06:08:37 +08:00
|
|
|
}
|
|
|
|
|
2016-03-26 05:59:14 +08:00
|
|
|
Expected<std::unique_ptr<MachOObjectFile>>
|
|
|
|
MachOObjectFile::create(MemoryBufferRef Object, bool IsLittleEndian,
|
|
|
|
bool Is64Bits) {
|
2016-03-26 07:54:32 +08:00
|
|
|
Error Err;
|
2016-03-26 05:59:14 +08:00
|
|
|
std::unique_ptr<MachOObjectFile> Obj(
|
|
|
|
new MachOObjectFile(std::move(Object), IsLittleEndian,
|
|
|
|
Is64Bits, Err));
|
|
|
|
if (Err)
|
|
|
|
return std::move(Err);
|
|
|
|
return std::move(Obj);
|
|
|
|
}
|
|
|
|
|
2014-08-20 02:44:46 +08:00
|
|
|
MachOObjectFile::MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian,
|
2016-03-26 01:25:34 +08:00
|
|
|
bool Is64bits, Error &Err)
|
2014-08-20 02:44:46 +08:00
|
|
|
: ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object),
|
2014-04-15 14:32:26 +08:00
|
|
|
SymtabLoadCmd(nullptr), DysymtabLoadCmd(nullptr),
|
2015-01-28 05:28:24 +08:00
|
|
|
DataInCodeLoadCmd(nullptr), LinkOptHintsLoadCmd(nullptr),
|
|
|
|
DyldInfoLoadCmd(nullptr), UuidLoadCmd(nullptr),
|
|
|
|
HasPageZeroSegment(false) {
|
2016-03-26 07:54:32 +08:00
|
|
|
ErrorAsOutParameter ErrAsOutParam(Err);
|
2016-04-22 04:29:49 +08:00
|
|
|
uint64_t BigSize;
|
2016-04-14 05:17:58 +08:00
|
|
|
if (is64Bit()) {
|
2016-03-26 01:25:34 +08:00
|
|
|
parseHeader(this, Header64, Err);
|
2016-04-22 04:29:49 +08:00
|
|
|
BigSize = sizeof(MachO::mach_header_64);
|
2016-04-14 05:17:58 +08:00
|
|
|
} else {
|
2016-03-26 01:25:34 +08:00
|
|
|
parseHeader(this, Header, Err);
|
2016-04-22 04:29:49 +08:00
|
|
|
BigSize = sizeof(MachO::mach_header);
|
2016-04-14 05:17:58 +08:00
|
|
|
}
|
2016-03-26 01:25:34 +08:00
|
|
|
if (Err)
|
2015-06-05 03:45:22 +08:00
|
|
|
return;
|
2016-04-22 04:29:49 +08:00
|
|
|
BigSize += getHeader().sizeofcmds;
|
|
|
|
if (getData().data() + BigSize > getData().end()) {
|
2016-05-06 07:41:05 +08:00
|
|
|
Err = malformedError(*this, "load commands extend past the end of the file");
|
2016-04-14 05:17:58 +08:00
|
|
|
return;
|
|
|
|
}
|
2015-06-05 03:22:03 +08:00
|
|
|
|
|
|
|
uint32_t LoadCommandCount = getHeader().ncmds;
|
2015-01-07 01:08:26 +08:00
|
|
|
if (LoadCommandCount == 0)
|
|
|
|
return;
|
|
|
|
|
2016-03-26 01:25:34 +08:00
|
|
|
LoadCommandInfo Load;
|
|
|
|
if (auto LoadOrErr = getFirstLoadCommandInfo(this))
|
|
|
|
Load = *LoadOrErr;
|
|
|
|
else {
|
|
|
|
Err = LoadOrErr.takeError();
|
2015-06-05 03:57:46 +08:00
|
|
|
return;
|
|
|
|
}
|
2016-03-26 01:25:34 +08:00
|
|
|
|
2015-06-04 06:19:36 +08:00
|
|
|
for (unsigned I = 0; I < LoadCommandCount; ++I) {
|
|
|
|
LoadCommands.push_back(Load);
|
2013-09-01 12:28:48 +08:00
|
|
|
if (Load.C.cmd == MachO::LC_SYMTAB) {
|
2014-11-14 03:48:56 +08:00
|
|
|
// Multiple symbol tables
|
|
|
|
if (SymtabLoadCmd) {
|
2016-03-26 01:25:34 +08:00
|
|
|
Err = malformedError(*this, "Multiple symbol tables");
|
2014-11-14 03:48:56 +08:00
|
|
|
return;
|
|
|
|
}
|
2013-04-19 02:08:55 +08:00
|
|
|
SymtabLoadCmd = Load.Ptr;
|
2013-09-01 12:28:48 +08:00
|
|
|
} else if (Load.C.cmd == MachO::LC_DYSYMTAB) {
|
2014-11-14 03:48:56 +08:00
|
|
|
// Multiple dynamic symbol tables
|
|
|
|
if (DysymtabLoadCmd) {
|
2016-03-26 01:25:34 +08:00
|
|
|
Err = malformedError(*this, "Multiple dynamic symbol tables");
|
2014-11-14 03:48:56 +08:00
|
|
|
return;
|
|
|
|
}
|
2013-04-27 04:07:33 +08:00
|
|
|
DysymtabLoadCmd = Load.Ptr;
|
2013-09-01 12:28:48 +08:00
|
|
|
} else if (Load.C.cmd == MachO::LC_DATA_IN_CODE) {
|
2014-11-14 03:48:56 +08:00
|
|
|
// Multiple data in code tables
|
|
|
|
if (DataInCodeLoadCmd) {
|
2016-03-26 01:25:34 +08:00
|
|
|
Err = malformedError(*this, "Multiple data-in-code tables");
|
2014-11-14 03:48:56 +08:00
|
|
|
return;
|
|
|
|
}
|
2013-06-07 01:20:50 +08:00
|
|
|
DataInCodeLoadCmd = Load.Ptr;
|
2015-01-28 05:28:24 +08:00
|
|
|
} else if (Load.C.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT) {
|
|
|
|
// Multiple linker optimization hint tables
|
|
|
|
if (LinkOptHintsLoadCmd) {
|
2016-03-26 01:25:34 +08:00
|
|
|
Err = malformedError(*this, "Multiple linker optimization hint tables");
|
2015-01-28 05:28:24 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
LinkOptHintsLoadCmd = Load.Ptr;
|
2015-09-22 19:19:03 +08:00
|
|
|
} else if (Load.C.cmd == MachO::LC_DYLD_INFO ||
|
2014-08-30 08:20:14 +08:00
|
|
|
Load.C.cmd == MachO::LC_DYLD_INFO_ONLY) {
|
2014-11-14 03:48:56 +08:00
|
|
|
// Multiple dyldinfo load commands
|
|
|
|
if (DyldInfoLoadCmd) {
|
2016-03-26 01:25:34 +08:00
|
|
|
Err = malformedError(*this, "Multiple dyldinfo load commands");
|
2014-11-14 03:48:56 +08:00
|
|
|
return;
|
|
|
|
}
|
2014-08-30 08:20:14 +08:00
|
|
|
DyldInfoLoadCmd = Load.Ptr;
|
2014-10-16 07:35:45 +08:00
|
|
|
} else if (Load.C.cmd == MachO::LC_UUID) {
|
2014-11-14 03:48:56 +08:00
|
|
|
// Multiple UUID load commands
|
|
|
|
if (UuidLoadCmd) {
|
2016-03-26 01:25:34 +08:00
|
|
|
Err = malformedError(*this, "Multiple UUID load commands");
|
2014-11-14 03:48:56 +08:00
|
|
|
return;
|
|
|
|
}
|
2014-10-16 07:35:45 +08:00
|
|
|
UuidLoadCmd = Load.Ptr;
|
2015-06-05 06:08:37 +08:00
|
|
|
} else if (Load.C.cmd == MachO::LC_SEGMENT_64) {
|
2016-03-26 01:25:34 +08:00
|
|
|
if ((Err = parseSegmentLoadCommand<MachO::segment_command_64>(
|
2016-05-06 01:43:35 +08:00
|
|
|
this, Load, Sections, HasPageZeroSegment, I,
|
|
|
|
"LC_SEGMENT_64")))
|
2015-06-05 04:08:52 +08:00
|
|
|
return;
|
2015-06-05 06:08:37 +08:00
|
|
|
} else if (Load.C.cmd == MachO::LC_SEGMENT) {
|
2016-03-26 01:25:34 +08:00
|
|
|
if ((Err = parseSegmentLoadCommand<MachO::segment_command>(
|
2016-05-06 01:43:35 +08:00
|
|
|
this, Load, Sections, HasPageZeroSegment, I, "LC_SEGMENT")))
|
2015-06-05 04:08:52 +08:00
|
|
|
return;
|
2014-06-06 05:21:57 +08:00
|
|
|
} else if (Load.C.cmd == MachO::LC_LOAD_DYLIB ||
|
|
|
|
Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
|
|
|
|
Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB ||
|
|
|
|
Load.C.cmd == MachO::LC_REEXPORT_DYLIB ||
|
|
|
|
Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) {
|
|
|
|
Libraries.push_back(Load.Ptr);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
2015-06-05 03:57:46 +08:00
|
|
|
if (I < LoadCommandCount - 1) {
|
2016-05-04 01:16:08 +08:00
|
|
|
if (auto LoadOrErr = getNextLoadCommandInfo(this, I, Load))
|
2016-03-26 01:25:34 +08:00
|
|
|
Load = *LoadOrErr;
|
|
|
|
else {
|
|
|
|
Err = LoadOrErr.takeError();
|
2015-06-05 03:57:46 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
2016-01-23 06:49:55 +08:00
|
|
|
if (!SymtabLoadCmd) {
|
|
|
|
if (DysymtabLoadCmd) {
|
2016-05-06 07:41:05 +08:00
|
|
|
Err = malformedError(*this, "contains LC_DYSYMTAB load command without a "
|
|
|
|
"LC_SYMTAB load command");
|
2016-01-23 06:49:55 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else if (DysymtabLoadCmd) {
|
|
|
|
MachO::symtab_command Symtab =
|
|
|
|
getStruct<MachO::symtab_command>(this, SymtabLoadCmd);
|
|
|
|
MachO::dysymtab_command Dysymtab =
|
|
|
|
getStruct<MachO::dysymtab_command>(this, DysymtabLoadCmd);
|
|
|
|
if (Dysymtab.nlocalsym != 0 && Dysymtab.ilocalsym > Symtab.nsyms) {
|
2016-05-06 07:41:05 +08:00
|
|
|
Err = malformedError(*this, "ilocalsym in LC_DYSYMTAB load command "
|
|
|
|
"extends past the end of the symbol table");
|
2016-01-23 06:49:55 +08:00
|
|
|
return;
|
|
|
|
}
|
2016-04-22 04:29:49 +08:00
|
|
|
uint64_t BigSize = Dysymtab.ilocalsym;
|
|
|
|
BigSize += Dysymtab.nlocalsym;
|
|
|
|
if (Dysymtab.nlocalsym != 0 && BigSize > Symtab.nsyms) {
|
2016-05-06 07:41:05 +08:00
|
|
|
Err = malformedError(*this, "ilocalsym plus nlocalsym in LC_DYSYMTAB load "
|
|
|
|
"command extends past the end of the symbol table");
|
2016-01-23 06:49:55 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (Dysymtab.nextdefsym != 0 && Dysymtab.ilocalsym > Symtab.nsyms) {
|
2016-05-06 07:41:05 +08:00
|
|
|
Err = malformedError(*this, "nextdefsym in LC_DYSYMTAB load command "
|
|
|
|
"extends past the end of the symbol table");
|
2016-01-23 06:49:55 +08:00
|
|
|
return;
|
|
|
|
}
|
2016-04-22 04:29:49 +08:00
|
|
|
BigSize = Dysymtab.iextdefsym;
|
|
|
|
BigSize += Dysymtab.nextdefsym;
|
|
|
|
if (Dysymtab.nextdefsym != 0 && BigSize > Symtab.nsyms) {
|
2016-05-06 07:41:05 +08:00
|
|
|
Err = malformedError(*this, "iextdefsym plus nextdefsym in LC_DYSYMTAB "
|
|
|
|
"load command extends past the end of the symbol "
|
|
|
|
"table");
|
2016-01-23 06:49:55 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (Dysymtab.nundefsym != 0 && Dysymtab.iundefsym > Symtab.nsyms) {
|
2016-05-06 07:41:05 +08:00
|
|
|
Err = malformedError(*this, "nundefsym in LC_DYSYMTAB load command "
|
|
|
|
"extends past the end of the symbol table");
|
2016-01-23 06:49:55 +08:00
|
|
|
return;
|
|
|
|
}
|
2016-04-22 04:29:49 +08:00
|
|
|
BigSize = Dysymtab.iundefsym;
|
|
|
|
BigSize += Dysymtab.nundefsym;
|
|
|
|
if (Dysymtab.nundefsym != 0 && BigSize > Symtab.nsyms) {
|
2016-05-06 07:41:05 +08:00
|
|
|
Err = malformedError(*this, "iundefsym plus nundefsym in LC_DYSYMTAB load "
|
|
|
|
" command extends past the end of the symbol table");
|
2016-01-23 06:49:55 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2015-06-04 06:19:36 +08:00
|
|
|
assert(LoadCommands.size() == LoadCommandCount);
|
2016-03-26 01:25:34 +08:00
|
|
|
|
|
|
|
Err = Error::success();
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-01-30 10:49:50 +08:00
|
|
|
void MachOObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
|
2013-04-25 03:47:55 +08:00
|
|
|
unsigned SymbolTableEntrySize = is64Bit() ?
|
2013-09-01 12:28:48 +08:00
|
|
|
sizeof(MachO::nlist_64) :
|
|
|
|
sizeof(MachO::nlist);
|
2013-04-25 03:47:55 +08:00
|
|
|
Symb.p += SymbolTableEntrySize;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2016-04-21 05:24:34 +08:00
|
|
|
Expected<StringRef> MachOObjectFile::getSymbolName(DataRefImpl Symb) const {
|
2013-04-27 04:07:33 +08:00
|
|
|
StringRef StringTable = getStringTableData();
|
2014-07-18 17:26:16 +08:00
|
|
|
MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb);
|
2013-09-01 12:28:48 +08:00
|
|
|
const char *Start = &StringTable.data()[Entry.n_strx];
|
2016-04-21 05:24:34 +08:00
|
|
|
if (Start < getData().begin() || Start >= getData().end()) {
|
2016-05-06 07:41:05 +08:00
|
|
|
return malformedError(*this, "bad string index: " + Twine(Entry.n_strx) +
|
|
|
|
" for symbol at index " + Twine(getSymbolIndex(Symb)));
|
2016-04-21 05:24:34 +08:00
|
|
|
}
|
2015-07-03 04:55:21 +08:00
|
|
|
return StringRef(Start);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-12-11 04:46:55 +08:00
|
|
|
unsigned MachOObjectFile::getSectionType(SectionRef Sec) const {
|
|
|
|
DataRefImpl DRI = Sec.getRawDataRefImpl();
|
|
|
|
uint32_t Flags = getSectionFlags(this, DRI);
|
|
|
|
return Flags & MachO::SECTION_TYPE;
|
|
|
|
}
|
|
|
|
|
2015-06-25 02:14:41 +08:00
|
|
|
uint64_t MachOObjectFile::getNValue(DataRefImpl Sym) const {
|
|
|
|
if (is64Bit()) {
|
|
|
|
MachO::nlist_64 Entry = getSymbol64TableEntry(Sym);
|
|
|
|
return Entry.n_value;
|
|
|
|
}
|
|
|
|
MachO::nlist Entry = getSymbolTableEntry(Sym);
|
|
|
|
return Entry.n_value;
|
|
|
|
}
|
|
|
|
|
2014-06-06 05:21:57 +08:00
|
|
|
// getIndirectName() returns the name of the alias'ed symbol who's string table
|
|
|
|
// index is in the n_value field.
|
2014-06-13 05:46:39 +08:00
|
|
|
std::error_code MachOObjectFile::getIndirectName(DataRefImpl Symb,
|
|
|
|
StringRef &Res) const {
|
2014-06-06 05:21:57 +08:00
|
|
|
StringRef StringTable = getStringTableData();
|
2015-06-25 02:14:41 +08:00
|
|
|
MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb);
|
|
|
|
if ((Entry.n_type & MachO::N_TYPE) != MachO::N_INDR)
|
|
|
|
return object_error::parse_failed;
|
|
|
|
uint64_t NValue = getNValue(Symb);
|
2014-06-06 05:21:57 +08:00
|
|
|
if (NValue >= StringTable.size())
|
|
|
|
return object_error::parse_failed;
|
|
|
|
const char *Start = &StringTable.data()[NValue];
|
|
|
|
Res = StringRef(Start);
|
2015-06-09 23:20:42 +08:00
|
|
|
return std::error_code();
|
2014-06-06 05:21:57 +08:00
|
|
|
}
|
|
|
|
|
2015-07-08 01:12:59 +08:00
|
|
|
uint64_t MachOObjectFile::getSymbolValueImpl(DataRefImpl Sym) const {
|
2015-07-07 23:05:09 +08:00
|
|
|
return getNValue(Sym);
|
2015-06-25 03:11:10 +08:00
|
|
|
}
|
|
|
|
|
2015-07-04 02:19:00 +08:00
|
|
|
ErrorOr<uint64_t> MachOObjectFile::getSymbolAddress(DataRefImpl Sym) const {
|
|
|
|
return getSymbolValue(Sym);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2015-06-01 07:52:50 +08:00
|
|
|
uint32_t MachOObjectFile::getSymbolAlignment(DataRefImpl DRI) const {
|
2014-02-01 04:57:12 +08:00
|
|
|
uint32_t flags = getSymbolFlags(DRI);
|
2013-04-30 06:24:22 +08:00
|
|
|
if (flags & SymbolRef::SF_Common) {
|
2014-07-18 17:26:16 +08:00
|
|
|
MachO::nlist_base Entry = getSymbolTableEntryBase(this, DRI);
|
2015-06-01 07:52:50 +08:00
|
|
|
return 1 << MachO::GET_COMM_ALIGN(Entry.n_desc);
|
2013-04-30 06:24:22 +08:00
|
|
|
}
|
2015-06-01 07:52:50 +08:00
|
|
|
return 0;
|
2013-04-30 06:24:22 +08:00
|
|
|
}
|
|
|
|
|
2015-06-24 18:20:30 +08:00
|
|
|
uint64_t MachOObjectFile::getCommonSymbolSizeImpl(DataRefImpl DRI) const {
|
2015-07-07 21:58:32 +08:00
|
|
|
return getNValue(DRI);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2016-05-03 04:28:12 +08:00
|
|
|
Expected<SymbolRef::Type>
|
2016-03-24 04:27:00 +08:00
|
|
|
MachOObjectFile::getSymbolType(DataRefImpl Symb) const {
|
2014-07-18 17:26:16 +08:00
|
|
|
MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb);
|
2013-09-01 12:28:48 +08:00
|
|
|
uint8_t n_type = Entry.n_type;
|
2013-04-19 02:08:55 +08:00
|
|
|
|
|
|
|
// If this is a STAB debugging symbol, we can do nothing more.
|
2015-06-26 20:18:49 +08:00
|
|
|
if (n_type & MachO::N_STAB)
|
|
|
|
return SymbolRef::ST_Debug;
|
2013-04-19 02:08:55 +08:00
|
|
|
|
2013-08-27 13:00:13 +08:00
|
|
|
switch (n_type & MachO::N_TYPE) {
|
|
|
|
case MachO::N_UNDF :
|
2015-06-26 20:18:49 +08:00
|
|
|
return SymbolRef::ST_Unknown;
|
2013-08-27 13:00:13 +08:00
|
|
|
case MachO::N_SECT :
|
2016-05-03 04:28:12 +08:00
|
|
|
Expected<section_iterator> SecOrError = getSymbolSection(Symb);
|
2016-03-24 04:27:00 +08:00
|
|
|
if (!SecOrError)
|
2016-05-03 04:28:12 +08:00
|
|
|
return SecOrError.takeError();
|
2016-03-24 04:27:00 +08:00
|
|
|
section_iterator Sec = *SecOrError;
|
2015-11-12 17:40:29 +08:00
|
|
|
if (Sec->isData() || Sec->isBSS())
|
|
|
|
return SymbolRef::ST_Data;
|
2015-06-26 20:18:49 +08:00
|
|
|
return SymbolRef::ST_Function;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
2015-06-26 20:18:49 +08:00
|
|
|
return SymbolRef::ST_Other;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-02-01 04:57:12 +08:00
|
|
|
uint32_t MachOObjectFile::getSymbolFlags(DataRefImpl DRI) const {
|
2014-07-18 17:26:16 +08:00
|
|
|
MachO::nlist_base Entry = getSymbolTableEntryBase(this, DRI);
|
2013-04-19 02:08:55 +08:00
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
uint8_t MachOType = Entry.n_type;
|
|
|
|
uint16_t MachOFlags = Entry.n_desc;
|
2013-04-19 02:08:55 +08:00
|
|
|
|
2014-02-01 04:57:12 +08:00
|
|
|
uint32_t Result = SymbolRef::SF_None;
|
2013-04-19 02:08:55 +08:00
|
|
|
|
2014-05-30 21:22:59 +08:00
|
|
|
if ((MachOType & MachO::N_TYPE) == MachO::N_INDR)
|
|
|
|
Result |= SymbolRef::SF_Indirect;
|
|
|
|
|
2013-11-02 13:03:24 +08:00
|
|
|
if (MachOType & MachO::N_STAB)
|
2013-04-19 02:08:55 +08:00
|
|
|
Result |= SymbolRef::SF_FormatSpecific;
|
|
|
|
|
2013-08-27 13:00:13 +08:00
|
|
|
if (MachOType & MachO::N_EXT) {
|
2013-04-19 02:08:55 +08:00
|
|
|
Result |= SymbolRef::SF_Global;
|
2013-08-27 13:00:13 +08:00
|
|
|
if ((MachOType & MachO::N_TYPE) == MachO::N_UNDF) {
|
2015-07-07 21:58:32 +08:00
|
|
|
if (getNValue(DRI))
|
2013-04-30 06:24:22 +08:00
|
|
|
Result |= SymbolRef::SF_Common;
|
2015-07-07 22:26:39 +08:00
|
|
|
else
|
|
|
|
Result |= SymbolRef::SF_Undefined;
|
2013-04-30 06:24:22 +08:00
|
|
|
}
|
2015-01-16 06:33:30 +08:00
|
|
|
|
|
|
|
if (!(MachOType & MachO::N_PEXT))
|
|
|
|
Result |= SymbolRef::SF_Exported;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-08-27 13:00:13 +08:00
|
|
|
if (MachOFlags & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF))
|
2013-04-19 02:08:55 +08:00
|
|
|
Result |= SymbolRef::SF_Weak;
|
|
|
|
|
2014-08-19 04:21:02 +08:00
|
|
|
if (MachOFlags & (MachO::N_ARM_THUMB_DEF))
|
|
|
|
Result |= SymbolRef::SF_Thumb;
|
|
|
|
|
2013-08-27 13:00:13 +08:00
|
|
|
if ((MachOType & MachO::N_TYPE) == MachO::N_ABS)
|
2013-04-19 02:08:55 +08:00
|
|
|
Result |= SymbolRef::SF_Absolute;
|
|
|
|
|
2014-02-01 04:57:12 +08:00
|
|
|
return Result;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2016-05-03 04:28:12 +08:00
|
|
|
Expected<section_iterator>
|
2015-08-08 07:27:14 +08:00
|
|
|
MachOObjectFile::getSymbolSection(DataRefImpl Symb) const {
|
2014-07-18 17:26:16 +08:00
|
|
|
MachO::nlist_base Entry = getSymbolTableEntryBase(this, Symb);
|
2013-09-01 12:28:48 +08:00
|
|
|
uint8_t index = Entry.n_sect;
|
2013-04-19 02:08:55 +08:00
|
|
|
|
2015-08-08 07:27:14 +08:00
|
|
|
if (index == 0)
|
|
|
|
return section_end();
|
|
|
|
DataRefImpl DRI;
|
|
|
|
DRI.d.a = index - 1;
|
2016-03-24 04:27:00 +08:00
|
|
|
if (DRI.d.a >= Sections.size()){
|
2016-05-06 07:41:05 +08:00
|
|
|
return malformedError(*this, "bad section index: " + Twine((int)index) +
|
|
|
|
" for symbol at index " + Twine(getSymbolIndex(Symb)));
|
2016-03-24 04:27:00 +08:00
|
|
|
}
|
2015-08-08 07:27:14 +08:00
|
|
|
return section_iterator(SectionRef(DRI, this));
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2015-06-25 03:57:32 +08:00
|
|
|
unsigned MachOObjectFile::getSymbolSectionID(SymbolRef Sym) const {
|
|
|
|
MachO::nlist_base Entry =
|
|
|
|
getSymbolTableEntryBase(this, Sym.getRawDataRefImpl());
|
|
|
|
return Entry.n_sect - 1;
|
|
|
|
}
|
|
|
|
|
2014-01-30 10:49:50 +08:00
|
|
|
void MachOObjectFile::moveSectionNext(DataRefImpl &Sec) const {
|
2013-04-19 02:08:55 +08:00
|
|
|
Sec.d.a++;
|
|
|
|
}
|
|
|
|
|
2014-06-13 05:46:39 +08:00
|
|
|
std::error_code MachOObjectFile::getSectionName(DataRefImpl Sec,
|
|
|
|
StringRef &Result) const {
|
2013-04-19 02:08:55 +08:00
|
|
|
ArrayRef<char> Raw = getSectionRawName(Sec);
|
|
|
|
Result = parseSegmentOrSectionName(Raw.data());
|
2015-06-09 23:20:42 +08:00
|
|
|
return std::error_code();
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-10-08 23:28:58 +08:00
|
|
|
uint64_t MachOObjectFile::getSectionAddress(DataRefImpl Sec) const {
|
|
|
|
if (is64Bit())
|
|
|
|
return getSection64(Sec).addr;
|
|
|
|
return getSection(Sec).addr;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-10-08 23:28:58 +08:00
|
|
|
uint64_t MachOObjectFile::getSectionSize(DataRefImpl Sec) const {
|
2015-10-09 06:50:55 +08:00
|
|
|
// In the case if a malformed Mach-O file where the section offset is past
|
|
|
|
// the end of the file or some part of the section size is past the end of
|
|
|
|
// the file return a size of zero or a size that covers the rest of the file
|
|
|
|
// but does not extend past the end of the file.
|
|
|
|
uint32_t SectOffset, SectType;
|
|
|
|
uint64_t SectSize;
|
|
|
|
|
|
|
|
if (is64Bit()) {
|
|
|
|
MachO::section_64 Sect = getSection64(Sec);
|
|
|
|
SectOffset = Sect.offset;
|
|
|
|
SectSize = Sect.size;
|
|
|
|
SectType = Sect.flags & MachO::SECTION_TYPE;
|
|
|
|
} else {
|
|
|
|
MachO::section Sect = getSection(Sec);
|
|
|
|
SectOffset = Sect.offset;
|
|
|
|
SectSize = Sect.size;
|
|
|
|
SectType = Sect.flags & MachO::SECTION_TYPE;
|
|
|
|
}
|
|
|
|
if (SectType == MachO::S_ZEROFILL || SectType == MachO::S_GB_ZEROFILL)
|
|
|
|
return SectSize;
|
|
|
|
uint64_t FileSize = getData().size();
|
|
|
|
if (SectOffset > FileSize)
|
|
|
|
return 0;
|
|
|
|
if (FileSize - SectOffset < SectSize)
|
|
|
|
return FileSize - SectOffset;
|
|
|
|
return SectSize;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-06-13 05:46:39 +08:00
|
|
|
std::error_code MachOObjectFile::getSectionContents(DataRefImpl Sec,
|
|
|
|
StringRef &Res) const {
|
2013-04-19 02:08:55 +08:00
|
|
|
uint32_t Offset;
|
|
|
|
uint64_t Size;
|
|
|
|
|
|
|
|
if (is64Bit()) {
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::section_64 Sect = getSection64(Sec);
|
|
|
|
Offset = Sect.offset;
|
|
|
|
Size = Sect.size;
|
2013-04-19 02:08:55 +08:00
|
|
|
} else {
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::section Sect = getSection(Sec);
|
|
|
|
Offset = Sect.offset;
|
|
|
|
Size = Sect.size;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
Res = this->getData().substr(Offset, Size);
|
2015-06-09 23:20:42 +08:00
|
|
|
return std::error_code();
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-10-08 23:28:58 +08:00
|
|
|
uint64_t MachOObjectFile::getSectionAlignment(DataRefImpl Sec) const {
|
2013-04-19 02:08:55 +08:00
|
|
|
uint32_t Align;
|
|
|
|
if (is64Bit()) {
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::section_64 Sect = getSection64(Sec);
|
|
|
|
Align = Sect.align;
|
2013-04-19 02:08:55 +08:00
|
|
|
} else {
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::section Sect = getSection(Sec);
|
|
|
|
Align = Sect.align;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-10-08 23:28:58 +08:00
|
|
|
return uint64_t(1) << Align;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-10-08 23:28:58 +08:00
|
|
|
bool MachOObjectFile::isSectionText(DataRefImpl Sec) const {
|
2013-04-19 02:08:55 +08:00
|
|
|
uint32_t Flags = getSectionFlags(this, Sec);
|
2014-10-08 23:28:58 +08:00
|
|
|
return Flags & MachO::S_ATTR_PURE_INSTRUCTIONS;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-10-08 23:28:58 +08:00
|
|
|
bool MachOObjectFile::isSectionData(DataRefImpl Sec) const {
|
2014-05-20 04:36:02 +08:00
|
|
|
uint32_t Flags = getSectionFlags(this, Sec);
|
|
|
|
unsigned SectionType = Flags & MachO::SECTION_TYPE;
|
2014-10-08 23:28:58 +08:00
|
|
|
return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
|
|
|
|
!(SectionType == MachO::S_ZEROFILL ||
|
|
|
|
SectionType == MachO::S_GB_ZEROFILL);
|
2011-09-29 04:57:30 +08:00
|
|
|
}
|
|
|
|
|
2014-10-08 23:28:58 +08:00
|
|
|
bool MachOObjectFile::isSectionBSS(DataRefImpl Sec) const {
|
2014-05-20 04:36:02 +08:00
|
|
|
uint32_t Flags = getSectionFlags(this, Sec);
|
|
|
|
unsigned SectionType = Flags & MachO::SECTION_TYPE;
|
2014-10-08 23:28:58 +08:00
|
|
|
return !(Flags & MachO::S_ATTR_PURE_INSTRUCTIONS) &&
|
|
|
|
(SectionType == MachO::S_ZEROFILL ||
|
|
|
|
SectionType == MachO::S_GB_ZEROFILL);
|
2011-09-29 04:57:30 +08:00
|
|
|
}
|
|
|
|
|
2015-06-25 03:57:32 +08:00
|
|
|
unsigned MachOObjectFile::getSectionID(SectionRef Sec) const {
|
|
|
|
return Sec.getRawDataRefImpl().d.a;
|
|
|
|
}
|
|
|
|
|
2014-10-08 23:28:58 +08:00
|
|
|
bool MachOObjectFile::isSectionVirtual(DataRefImpl Sec) const {
|
2012-10-10 09:45:52 +08:00
|
|
|
// FIXME: Unimplemented.
|
2014-10-08 23:28:58 +08:00
|
|
|
return false;
|
2012-04-13 04:13:57 +08:00
|
|
|
}
|
|
|
|
|
2016-03-01 03:40:10 +08:00
|
|
|
bool MachOObjectFile::isSectionBitcode(DataRefImpl Sec) const {
|
|
|
|
StringRef SegmentName = getSectionFinalSegmentName(Sec);
|
|
|
|
StringRef SectName;
|
|
|
|
if (!getSectionName(Sec, SectName))
|
|
|
|
return (SegmentName == "__LLVM" && SectName == "__bitcode");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-09-28 05:47:05 +08:00
|
|
|
relocation_iterator MachOObjectFile::section_rel_begin(DataRefImpl Sec) const {
|
2013-04-25 20:45:46 +08:00
|
|
|
DataRefImpl Ret;
|
2014-04-04 07:51:28 +08:00
|
|
|
Ret.d.a = Sec.d.a;
|
|
|
|
Ret.d.b = 0;
|
2013-04-25 20:45:46 +08:00
|
|
|
return relocation_iterator(RelocationRef(Ret, this));
|
2011-10-08 03:25:32 +08:00
|
|
|
}
|
2013-04-09 04:45:01 +08:00
|
|
|
|
2013-04-19 02:08:55 +08:00
|
|
|
relocation_iterator
|
2013-09-28 05:47:05 +08:00
|
|
|
MachOObjectFile::section_rel_end(DataRefImpl Sec) const {
|
2013-04-25 20:45:46 +08:00
|
|
|
uint32_t Num;
|
2013-04-19 02:08:55 +08:00
|
|
|
if (is64Bit()) {
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::section_64 Sect = getSection64(Sec);
|
|
|
|
Num = Sect.nreloc;
|
2013-04-19 02:08:55 +08:00
|
|
|
} else {
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::section Sect = getSection(Sec);
|
|
|
|
Num = Sect.nreloc;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
2011-04-22 11:19:48 +08:00
|
|
|
|
2013-04-19 02:08:55 +08:00
|
|
|
DataRefImpl Ret;
|
2014-04-04 07:51:28 +08:00
|
|
|
Ret.d.a = Sec.d.a;
|
|
|
|
Ret.d.b = Num;
|
2013-04-19 02:08:55 +08:00
|
|
|
return relocation_iterator(RelocationRef(Ret, this));
|
|
|
|
}
|
2011-09-09 04:52:17 +08:00
|
|
|
|
2014-01-30 10:49:50 +08:00
|
|
|
void MachOObjectFile::moveRelocationNext(DataRefImpl &Rel) const {
|
2014-04-04 07:51:28 +08:00
|
|
|
++Rel.d.b;
|
2011-09-09 04:52:17 +08:00
|
|
|
}
|
2011-10-25 07:20:07 +08:00
|
|
|
|
2015-06-30 07:29:12 +08:00
|
|
|
uint64_t MachOObjectFile::getRelocationOffset(DataRefImpl Rel) const {
|
2014-04-04 08:31:12 +08:00
|
|
|
assert(getHeader().filetype == MachO::MH_OBJECT &&
|
|
|
|
"Only implemented for MH_OBJECT");
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::any_relocation_info RE = getRelocation(Rel);
|
2015-06-30 07:29:12 +08:00
|
|
|
return getAnyRelocationAddress(RE);
|
2012-03-01 09:36:50 +08:00
|
|
|
}
|
|
|
|
|
2013-06-05 09:33:53 +08:00
|
|
|
symbol_iterator
|
|
|
|
MachOObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::any_relocation_info RE = getRelocation(Rel);
|
2014-07-04 18:57:56 +08:00
|
|
|
if (isRelocationScattered(RE))
|
|
|
|
return symbol_end();
|
|
|
|
|
2013-04-19 02:08:55 +08:00
|
|
|
uint32_t SymbolIdx = getPlainRelocationSymbolNum(RE);
|
|
|
|
bool isExtern = getPlainRelocationExternal(RE);
|
2013-06-05 09:33:53 +08:00
|
|
|
if (!isExtern)
|
2014-02-11 04:24:04 +08:00
|
|
|
return symbol_end();
|
2013-04-19 02:08:55 +08:00
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::symtab_command S = getSymtabLoadCommand();
|
2013-04-25 03:47:55 +08:00
|
|
|
unsigned SymbolTableEntrySize = is64Bit() ?
|
2013-09-01 12:28:48 +08:00
|
|
|
sizeof(MachO::nlist_64) :
|
|
|
|
sizeof(MachO::nlist);
|
|
|
|
uint64_t Offset = S.symoff + SymbolIdx * SymbolTableEntrySize;
|
2013-04-19 02:08:55 +08:00
|
|
|
DataRefImpl Sym;
|
2013-04-25 03:47:55 +08:00
|
|
|
Sym.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset));
|
2013-06-05 09:33:53 +08:00
|
|
|
return symbol_iterator(SymbolRef(Sym, this));
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2015-05-22 05:24:32 +08:00
|
|
|
section_iterator
|
|
|
|
MachOObjectFile::getRelocationSection(DataRefImpl Rel) const {
|
|
|
|
return section_iterator(getAnyRelocationSection(getRelocation(Rel)));
|
|
|
|
}
|
|
|
|
|
2015-06-30 09:53:01 +08:00
|
|
|
uint64_t MachOObjectFile::getRelocationType(DataRefImpl Rel) const {
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::any_relocation_info RE = getRelocation(Rel);
|
2015-06-30 09:53:01 +08:00
|
|
|
return getAnyRelocationType(RE);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2015-06-30 12:08:37 +08:00
|
|
|
void MachOObjectFile::getRelocationTypeName(
|
|
|
|
DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
|
2013-04-19 02:08:55 +08:00
|
|
|
StringRef res;
|
2015-06-30 09:53:01 +08:00
|
|
|
uint64_t RType = getRelocationType(Rel);
|
2013-04-19 02:08:55 +08:00
|
|
|
|
|
|
|
unsigned Arch = this->getArch();
|
|
|
|
|
|
|
|
switch (Arch) {
|
|
|
|
case Triple::x86: {
|
|
|
|
static const char *const Table[] = {
|
|
|
|
"GENERIC_RELOC_VANILLA",
|
|
|
|
"GENERIC_RELOC_PAIR",
|
|
|
|
"GENERIC_RELOC_SECTDIFF",
|
|
|
|
"GENERIC_RELOC_PB_LA_PTR",
|
|
|
|
"GENERIC_RELOC_LOCAL_SECTDIFF",
|
|
|
|
"GENERIC_RELOC_TLV" };
|
|
|
|
|
2013-12-06 10:33:38 +08:00
|
|
|
if (RType > 5)
|
2013-04-19 02:08:55 +08:00
|
|
|
res = "Unknown";
|
|
|
|
else
|
|
|
|
res = Table[RType];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Triple::x86_64: {
|
|
|
|
static const char *const Table[] = {
|
|
|
|
"X86_64_RELOC_UNSIGNED",
|
|
|
|
"X86_64_RELOC_SIGNED",
|
|
|
|
"X86_64_RELOC_BRANCH",
|
|
|
|
"X86_64_RELOC_GOT_LOAD",
|
|
|
|
"X86_64_RELOC_GOT",
|
|
|
|
"X86_64_RELOC_SUBTRACTOR",
|
|
|
|
"X86_64_RELOC_SIGNED_1",
|
|
|
|
"X86_64_RELOC_SIGNED_2",
|
|
|
|
"X86_64_RELOC_SIGNED_4",
|
|
|
|
"X86_64_RELOC_TLV" };
|
|
|
|
|
|
|
|
if (RType > 9)
|
|
|
|
res = "Unknown";
|
|
|
|
else
|
|
|
|
res = Table[RType];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Triple::arm: {
|
|
|
|
static const char *const Table[] = {
|
|
|
|
"ARM_RELOC_VANILLA",
|
|
|
|
"ARM_RELOC_PAIR",
|
|
|
|
"ARM_RELOC_SECTDIFF",
|
|
|
|
"ARM_RELOC_LOCAL_SECTDIFF",
|
|
|
|
"ARM_RELOC_PB_LA_PTR",
|
|
|
|
"ARM_RELOC_BR24",
|
|
|
|
"ARM_THUMB_RELOC_BR22",
|
|
|
|
"ARM_THUMB_32BIT_BRANCH",
|
|
|
|
"ARM_RELOC_HALF",
|
|
|
|
"ARM_RELOC_HALF_SECTDIFF" };
|
|
|
|
|
|
|
|
if (RType > 9)
|
|
|
|
res = "Unknown";
|
|
|
|
else
|
|
|
|
res = Table[RType];
|
|
|
|
break;
|
|
|
|
}
|
2014-03-29 18:18:08 +08:00
|
|
|
case Triple::aarch64: {
|
|
|
|
static const char *const Table[] = {
|
|
|
|
"ARM64_RELOC_UNSIGNED", "ARM64_RELOC_SUBTRACTOR",
|
|
|
|
"ARM64_RELOC_BRANCH26", "ARM64_RELOC_PAGE21",
|
|
|
|
"ARM64_RELOC_PAGEOFF12", "ARM64_RELOC_GOT_LOAD_PAGE21",
|
|
|
|
"ARM64_RELOC_GOT_LOAD_PAGEOFF12", "ARM64_RELOC_POINTER_TO_GOT",
|
|
|
|
"ARM64_RELOC_TLVP_LOAD_PAGE21", "ARM64_RELOC_TLVP_LOAD_PAGEOFF12",
|
|
|
|
"ARM64_RELOC_ADDEND"
|
|
|
|
};
|
|
|
|
|
|
|
|
if (RType >= array_lengthof(Table))
|
|
|
|
res = "Unknown";
|
|
|
|
else
|
|
|
|
res = Table[RType];
|
|
|
|
break;
|
|
|
|
}
|
2013-04-19 02:08:55 +08:00
|
|
|
case Triple::ppc: {
|
|
|
|
static const char *const Table[] = {
|
|
|
|
"PPC_RELOC_VANILLA",
|
|
|
|
"PPC_RELOC_PAIR",
|
|
|
|
"PPC_RELOC_BR14",
|
|
|
|
"PPC_RELOC_BR24",
|
|
|
|
"PPC_RELOC_HI16",
|
|
|
|
"PPC_RELOC_LO16",
|
|
|
|
"PPC_RELOC_HA16",
|
|
|
|
"PPC_RELOC_LO14",
|
|
|
|
"PPC_RELOC_SECTDIFF",
|
|
|
|
"PPC_RELOC_PB_LA_PTR",
|
|
|
|
"PPC_RELOC_HI16_SECTDIFF",
|
|
|
|
"PPC_RELOC_LO16_SECTDIFF",
|
|
|
|
"PPC_RELOC_HA16_SECTDIFF",
|
|
|
|
"PPC_RELOC_JBSR",
|
|
|
|
"PPC_RELOC_LO14_SECTDIFF",
|
|
|
|
"PPC_RELOC_LOCAL_SECTDIFF" };
|
|
|
|
|
2013-12-06 10:33:38 +08:00
|
|
|
if (RType > 15)
|
|
|
|
res = "Unknown";
|
|
|
|
else
|
|
|
|
res = Table[RType];
|
2013-04-19 02:08:55 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Triple::UnknownArch:
|
|
|
|
res = "Unknown";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
Result.append(res.begin(), res.end());
|
|
|
|
}
|
|
|
|
|
2015-05-31 03:44:53 +08:00
|
|
|
uint8_t MachOObjectFile::getRelocationLength(DataRefImpl Rel) const {
|
|
|
|
MachO::any_relocation_info RE = getRelocation(Rel);
|
|
|
|
return getAnyRelocationLength(RE);
|
|
|
|
}
|
|
|
|
|
2014-06-06 05:21:57 +08:00
|
|
|
//
|
|
|
|
// guessLibraryShortName() is passed a name of a dynamic library and returns a
|
|
|
|
// guess on what the short name is. Then name is returned as a substring of the
|
|
|
|
// StringRef Name passed in. The name of the dynamic library is recognized as
|
|
|
|
// a framework if it has one of the two following forms:
|
|
|
|
// Foo.framework/Versions/A/Foo
|
|
|
|
// Foo.framework/Foo
|
|
|
|
// Where A and Foo can be any string. And may contain a trailing suffix
|
|
|
|
// starting with an underbar. If the Name is recognized as a framework then
|
|
|
|
// isFramework is set to true else it is set to false. If the Name has a
|
|
|
|
// suffix then Suffix is set to the substring in Name that contains the suffix
|
|
|
|
// else it is set to a NULL StringRef.
|
|
|
|
//
|
|
|
|
// The Name of the dynamic library is recognized as a library name if it has
|
|
|
|
// one of the two following forms:
|
|
|
|
// libFoo.A.dylib
|
|
|
|
// libFoo.dylib
|
|
|
|
// The library may have a suffix trailing the name Foo of the form:
|
|
|
|
// libFoo_profile.A.dylib
|
|
|
|
// libFoo_profile.dylib
|
|
|
|
//
|
|
|
|
// The Name of the dynamic library is also recognized as a library name if it
|
|
|
|
// has the following form:
|
|
|
|
// Foo.qtx
|
|
|
|
//
|
|
|
|
// If the Name of the dynamic library is none of the forms above then a NULL
|
|
|
|
// StringRef is returned.
|
|
|
|
//
|
|
|
|
StringRef MachOObjectFile::guessLibraryShortName(StringRef Name,
|
|
|
|
bool &isFramework,
|
|
|
|
StringRef &Suffix) {
|
|
|
|
StringRef Foo, F, DotFramework, V, Dylib, Lib, Dot, Qtx;
|
|
|
|
size_t a, b, c, d, Idx;
|
|
|
|
|
|
|
|
isFramework = false;
|
|
|
|
Suffix = StringRef();
|
|
|
|
|
|
|
|
// Pull off the last component and make Foo point to it
|
|
|
|
a = Name.rfind('/');
|
|
|
|
if (a == Name.npos || a == 0)
|
|
|
|
goto guess_library;
|
|
|
|
Foo = Name.slice(a+1, Name.npos);
|
|
|
|
|
|
|
|
// Look for a suffix starting with a '_'
|
|
|
|
Idx = Foo.rfind('_');
|
|
|
|
if (Idx != Foo.npos && Foo.size() >= 2) {
|
|
|
|
Suffix = Foo.slice(Idx, Foo.npos);
|
|
|
|
Foo = Foo.slice(0, Idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
// First look for the form Foo.framework/Foo
|
|
|
|
b = Name.rfind('/', a);
|
|
|
|
if (b == Name.npos)
|
|
|
|
Idx = 0;
|
|
|
|
else
|
|
|
|
Idx = b+1;
|
|
|
|
F = Name.slice(Idx, Idx + Foo.size());
|
|
|
|
DotFramework = Name.slice(Idx + Foo.size(),
|
|
|
|
Idx + Foo.size() + sizeof(".framework/")-1);
|
|
|
|
if (F == Foo && DotFramework == ".framework/") {
|
|
|
|
isFramework = true;
|
|
|
|
return Foo;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Next look for the form Foo.framework/Versions/A/Foo
|
|
|
|
if (b == Name.npos)
|
|
|
|
goto guess_library;
|
|
|
|
c = Name.rfind('/', b);
|
|
|
|
if (c == Name.npos || c == 0)
|
|
|
|
goto guess_library;
|
|
|
|
V = Name.slice(c+1, Name.npos);
|
|
|
|
if (!V.startswith("Versions/"))
|
|
|
|
goto guess_library;
|
|
|
|
d = Name.rfind('/', c);
|
|
|
|
if (d == Name.npos)
|
|
|
|
Idx = 0;
|
|
|
|
else
|
|
|
|
Idx = d+1;
|
|
|
|
F = Name.slice(Idx, Idx + Foo.size());
|
|
|
|
DotFramework = Name.slice(Idx + Foo.size(),
|
|
|
|
Idx + Foo.size() + sizeof(".framework/")-1);
|
|
|
|
if (F == Foo && DotFramework == ".framework/") {
|
|
|
|
isFramework = true;
|
|
|
|
return Foo;
|
|
|
|
}
|
|
|
|
|
|
|
|
guess_library:
|
|
|
|
// pull off the suffix after the "." and make a point to it
|
|
|
|
a = Name.rfind('.');
|
|
|
|
if (a == Name.npos || a == 0)
|
|
|
|
return StringRef();
|
|
|
|
Dylib = Name.slice(a, Name.npos);
|
|
|
|
if (Dylib != ".dylib")
|
|
|
|
goto guess_qtx;
|
|
|
|
|
|
|
|
// First pull off the version letter for the form Foo.A.dylib if any.
|
|
|
|
if (a >= 3) {
|
|
|
|
Dot = Name.slice(a-2, a-1);
|
|
|
|
if (Dot == ".")
|
|
|
|
a = a - 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
b = Name.rfind('/', a);
|
|
|
|
if (b == Name.npos)
|
|
|
|
b = 0;
|
|
|
|
else
|
|
|
|
b = b+1;
|
|
|
|
// ignore any suffix after an underbar like Foo_profile.A.dylib
|
|
|
|
Idx = Name.find('_', b);
|
|
|
|
if (Idx != Name.npos && Idx != b) {
|
|
|
|
Lib = Name.slice(b, Idx);
|
|
|
|
Suffix = Name.slice(Idx, a);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Lib = Name.slice(b, a);
|
|
|
|
// There are incorrect library names of the form:
|
|
|
|
// libATS.A_profile.dylib so check for these.
|
|
|
|
if (Lib.size() >= 3) {
|
|
|
|
Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
|
|
|
|
if (Dot == ".")
|
|
|
|
Lib = Lib.slice(0, Lib.size()-2);
|
|
|
|
}
|
|
|
|
return Lib;
|
|
|
|
|
|
|
|
guess_qtx:
|
|
|
|
Qtx = Name.slice(a, Name.npos);
|
|
|
|
if (Qtx != ".qtx")
|
|
|
|
return StringRef();
|
|
|
|
b = Name.rfind('/', a);
|
|
|
|
if (b == Name.npos)
|
|
|
|
Lib = Name.slice(0, a);
|
|
|
|
else
|
|
|
|
Lib = Name.slice(b+1, a);
|
|
|
|
// There are library names of the form: QT.A.qtx so check for these.
|
|
|
|
if (Lib.size() >= 3) {
|
|
|
|
Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
|
|
|
|
if (Dot == ".")
|
|
|
|
Lib = Lib.slice(0, Lib.size()-2);
|
|
|
|
}
|
|
|
|
return Lib;
|
|
|
|
}
|
|
|
|
|
|
|
|
// getLibraryShortNameByIndex() is used to get the short name of the library
|
|
|
|
// for an undefined symbol in a linked Mach-O binary that was linked with the
|
|
|
|
// normal two-level namespace default (that is MH_TWOLEVEL in the header).
|
|
|
|
// It is passed the index (0 - based) of the library as translated from
|
|
|
|
// GET_LIBRARY_ORDINAL (1 - based).
|
2014-06-13 05:46:39 +08:00
|
|
|
std::error_code MachOObjectFile::getLibraryShortNameByIndex(unsigned Index,
|
2014-08-30 08:20:14 +08:00
|
|
|
StringRef &Res) const {
|
2014-06-06 05:21:57 +08:00
|
|
|
if (Index >= Libraries.size())
|
|
|
|
return object_error::parse_failed;
|
|
|
|
|
|
|
|
// If the cache of LibrariesShortNames is not built up do that first for
|
|
|
|
// all the Libraries.
|
|
|
|
if (LibrariesShortNames.size() == 0) {
|
|
|
|
for (unsigned i = 0; i < Libraries.size(); i++) {
|
|
|
|
MachO::dylib_command D =
|
|
|
|
getStruct<MachO::dylib_command>(this, Libraries[i]);
|
2014-09-17 08:25:22 +08:00
|
|
|
if (D.dylib.name >= D.cmdsize)
|
|
|
|
return object_error::parse_failed;
|
2014-06-21 02:07:34 +08:00
|
|
|
const char *P = (const char *)(Libraries[i]) + D.dylib.name;
|
2014-06-06 05:21:57 +08:00
|
|
|
StringRef Name = StringRef(P);
|
2014-09-17 08:25:22 +08:00
|
|
|
if (D.dylib.name+Name.size() >= D.cmdsize)
|
|
|
|
return object_error::parse_failed;
|
2014-06-06 05:21:57 +08:00
|
|
|
StringRef Suffix;
|
|
|
|
bool isFramework;
|
|
|
|
StringRef shortName = guessLibraryShortName(Name, isFramework, Suffix);
|
2014-09-17 08:25:22 +08:00
|
|
|
if (shortName.empty())
|
2014-06-06 05:21:57 +08:00
|
|
|
LibrariesShortNames.push_back(Name);
|
|
|
|
else
|
|
|
|
LibrariesShortNames.push_back(shortName);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Res = LibrariesShortNames[Index];
|
2015-06-09 23:20:42 +08:00
|
|
|
return std::error_code();
|
2014-06-06 05:21:57 +08:00
|
|
|
}
|
|
|
|
|
Remove getRelocationAddress.
Originally added in r139314.
Back then it didn't actually get the address, it got whatever value the
relocation used: address or offset.
The values in different object formats are:
* MachO: Always an offset.
* COFF: Always an address, but when talking about the virtual address of
sections it says: "for simplicity, compilers should set this to zero".
* ELF: An offset for .o files and and address for .so files. In the case of the
.so, the relocation in not linked to any section (sh_info is 0). We can't
really compute an offset.
Some API mappings would be:
* Use getAddress for everything. It would be quite cumbersome. To compute the
address elf has to follow sh_info, which can be corrupted and therefore the
method has to return an ErrorOr. The address of the section is also the same
for every relocation in a section, so we shouldn't have to check the error
and fetch the value for every relocation.
* Use a getValue and make it up to the user to know what it is getting.
* Use a getOffset and:
* Assert for dynamic ELF objects. That is a very peculiar case and it is
probably fair to ask any tool that wants to support it to use ELF.h. The
only tool we have that reads those (llvm-readobj) already does that. The
only other use case I can think of is a dynamic linker.
* Check that COFF .obj files have sections with zero virtual address spaces. If
it turns out that some assembler/compiler produces these, we can change
COFFObjectFile::getRelocationOffset to subtract it. Given COFF format,
this can be done without the need for ErrorOr.
The getRelocationAddress method was never implemented for COFF. It also
had exactly one use in a very peculiar case: a shortcut for adding the
section value to a pcrel reloc on MachO.
Given that, I don't expect that there is any use out there of the C API. If
that is not the case, let me know and I will add it back with the implementation
inlined and do a proper deprecation.
llvm-svn: 241450
2015-07-06 22:55:37 +08:00
|
|
|
section_iterator
|
|
|
|
MachOObjectFile::getRelocationRelocatedSection(relocation_iterator Rel) const {
|
|
|
|
DataRefImpl Sec;
|
|
|
|
Sec.d.a = Rel->getRawDataRefImpl().d.a;
|
|
|
|
return section_iterator(SectionRef(Sec, this));
|
|
|
|
}
|
|
|
|
|
2014-02-22 04:10:59 +08:00
|
|
|
basic_symbol_iterator MachOObjectFile::symbol_begin_impl() const {
|
2016-01-23 06:49:55 +08:00
|
|
|
DataRefImpl DRI;
|
|
|
|
MachO::symtab_command Symtab = getSymtabLoadCommand();
|
|
|
|
if (!SymtabLoadCmd || Symtab.nsyms == 0)
|
|
|
|
return basic_symbol_iterator(SymbolRef(DRI, this));
|
|
|
|
|
2014-05-13 05:39:59 +08:00
|
|
|
return getSymbolByIndex(0);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-02-22 04:10:59 +08:00
|
|
|
basic_symbol_iterator MachOObjectFile::symbol_end_impl() const {
|
2013-04-19 02:08:55 +08:00
|
|
|
DataRefImpl DRI;
|
2016-01-23 06:49:55 +08:00
|
|
|
MachO::symtab_command Symtab = getSymtabLoadCommand();
|
|
|
|
if (!SymtabLoadCmd || Symtab.nsyms == 0)
|
2014-02-22 04:10:59 +08:00
|
|
|
return basic_symbol_iterator(SymbolRef(DRI, this));
|
2013-04-25 03:47:55 +08:00
|
|
|
|
|
|
|
unsigned SymbolTableEntrySize = is64Bit() ?
|
2013-09-01 12:28:48 +08:00
|
|
|
sizeof(MachO::nlist_64) :
|
|
|
|
sizeof(MachO::nlist);
|
|
|
|
unsigned Offset = Symtab.symoff +
|
|
|
|
Symtab.nsyms * SymbolTableEntrySize;
|
2013-04-25 03:47:55 +08:00
|
|
|
DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset));
|
2014-02-22 04:10:59 +08:00
|
|
|
return basic_symbol_iterator(SymbolRef(DRI, this));
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-05-13 05:39:59 +08:00
|
|
|
basic_symbol_iterator MachOObjectFile::getSymbolByIndex(unsigned Index) const {
|
|
|
|
MachO::symtab_command Symtab = getSymtabLoadCommand();
|
2016-01-23 06:49:55 +08:00
|
|
|
if (!SymtabLoadCmd || Index >= Symtab.nsyms)
|
2015-01-16 06:52:38 +08:00
|
|
|
report_fatal_error("Requested symbol index is out of range.");
|
2014-05-13 05:39:59 +08:00
|
|
|
unsigned SymbolTableEntrySize =
|
|
|
|
is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
|
2016-01-23 06:49:55 +08:00
|
|
|
DataRefImpl DRI;
|
2014-05-13 05:39:59 +08:00
|
|
|
DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Symtab.symoff));
|
|
|
|
DRI.p += Index * SymbolTableEntrySize;
|
|
|
|
return basic_symbol_iterator(SymbolRef(DRI, this));
|
|
|
|
}
|
|
|
|
|
2016-04-21 05:24:34 +08:00
|
|
|
uint64_t MachOObjectFile::getSymbolIndex(DataRefImpl Symb) const {
|
|
|
|
MachO::symtab_command Symtab = getSymtabLoadCommand();
|
|
|
|
if (!SymtabLoadCmd)
|
|
|
|
report_fatal_error("getSymbolIndex() called with no symbol table symbol");
|
|
|
|
unsigned SymbolTableEntrySize =
|
|
|
|
is64Bit() ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
|
|
|
|
DataRefImpl DRIstart;
|
|
|
|
DRIstart.p = reinterpret_cast<uintptr_t>(getPtr(this, Symtab.symoff));
|
|
|
|
uint64_t Index = (Symb.p - DRIstart.p) / SymbolTableEntrySize;
|
|
|
|
return Index;
|
|
|
|
}
|
|
|
|
|
2014-02-11 04:24:04 +08:00
|
|
|
section_iterator MachOObjectFile::section_begin() const {
|
2013-04-19 02:08:55 +08:00
|
|
|
DataRefImpl DRI;
|
|
|
|
return section_iterator(SectionRef(DRI, this));
|
|
|
|
}
|
|
|
|
|
2014-02-11 04:24:04 +08:00
|
|
|
section_iterator MachOObjectFile::section_end() const {
|
2013-04-19 02:08:55 +08:00
|
|
|
DataRefImpl DRI;
|
|
|
|
DRI.d.a = Sections.size();
|
|
|
|
return section_iterator(SectionRef(DRI, this));
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t MachOObjectFile::getBytesInAddress() const {
|
2013-04-08 03:05:30 +08:00
|
|
|
return is64Bit() ? 8 : 4;
|
2011-04-22 11:19:48 +08:00
|
|
|
}
|
|
|
|
|
2013-04-19 02:08:55 +08:00
|
|
|
StringRef MachOObjectFile::getFileFormatName() const {
|
|
|
|
unsigned CPUType = getCPUType(this);
|
|
|
|
if (!is64Bit()) {
|
|
|
|
switch (CPUType) {
|
2013-08-27 13:00:13 +08:00
|
|
|
case llvm::MachO::CPU_TYPE_I386:
|
2013-04-19 02:08:55 +08:00
|
|
|
return "Mach-O 32-bit i386";
|
2013-08-27 13:00:13 +08:00
|
|
|
case llvm::MachO::CPU_TYPE_ARM:
|
2013-04-19 02:08:55 +08:00
|
|
|
return "Mach-O arm";
|
2013-08-27 13:00:13 +08:00
|
|
|
case llvm::MachO::CPU_TYPE_POWERPC:
|
2013-04-19 02:08:55 +08:00
|
|
|
return "Mach-O 32-bit ppc";
|
|
|
|
default:
|
|
|
|
return "Mach-O 32-bit unknown";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (CPUType) {
|
2013-08-27 13:00:13 +08:00
|
|
|
case llvm::MachO::CPU_TYPE_X86_64:
|
2013-04-19 02:08:55 +08:00
|
|
|
return "Mach-O 64-bit x86-64";
|
2014-03-29 18:18:08 +08:00
|
|
|
case llvm::MachO::CPU_TYPE_ARM64:
|
|
|
|
return "Mach-O arm64";
|
2013-08-27 13:00:13 +08:00
|
|
|
case llvm::MachO::CPU_TYPE_POWERPC64:
|
2013-04-19 02:08:55 +08:00
|
|
|
return "Mach-O 64-bit ppc64";
|
|
|
|
default:
|
|
|
|
return "Mach-O 64-bit unknown";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-18 23:03:28 +08:00
|
|
|
Triple::ArchType MachOObjectFile::getArch(uint32_t CPUType) {
|
|
|
|
switch (CPUType) {
|
2013-08-27 13:00:13 +08:00
|
|
|
case llvm::MachO::CPU_TYPE_I386:
|
2013-04-19 02:08:55 +08:00
|
|
|
return Triple::x86;
|
2013-08-27 13:00:13 +08:00
|
|
|
case llvm::MachO::CPU_TYPE_X86_64:
|
2013-04-19 02:08:55 +08:00
|
|
|
return Triple::x86_64;
|
2013-08-27 13:00:13 +08:00
|
|
|
case llvm::MachO::CPU_TYPE_ARM:
|
2013-04-19 02:08:55 +08:00
|
|
|
return Triple::arm;
|
2014-03-29 18:18:08 +08:00
|
|
|
case llvm::MachO::CPU_TYPE_ARM64:
|
2014-07-23 20:32:47 +08:00
|
|
|
return Triple::aarch64;
|
2013-08-27 13:00:13 +08:00
|
|
|
case llvm::MachO::CPU_TYPE_POWERPC:
|
2013-04-19 02:08:55 +08:00
|
|
|
return Triple::ppc;
|
2013-08-27 13:00:13 +08:00
|
|
|
case llvm::MachO::CPU_TYPE_POWERPC64:
|
2013-04-19 02:08:55 +08:00
|
|
|
return Triple::ppc64;
|
|
|
|
default:
|
|
|
|
return Triple::UnknownArch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-23 07:21:13 +08:00
|
|
|
Triple MachOObjectFile::getArchTriple(uint32_t CPUType, uint32_t CPUSubType,
|
|
|
|
const char **McpuDefault) {
|
2014-08-19 04:21:02 +08:00
|
|
|
if (McpuDefault)
|
|
|
|
*McpuDefault = nullptr;
|
|
|
|
|
2014-07-01 02:45:23 +08:00
|
|
|
switch (CPUType) {
|
|
|
|
case MachO::CPU_TYPE_I386:
|
|
|
|
switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
|
|
|
|
case MachO::CPU_SUBTYPE_I386_ALL:
|
|
|
|
return Triple("i386-apple-darwin");
|
|
|
|
default:
|
|
|
|
return Triple();
|
|
|
|
}
|
|
|
|
case MachO::CPU_TYPE_X86_64:
|
|
|
|
switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
|
|
|
|
case MachO::CPU_SUBTYPE_X86_64_ALL:
|
|
|
|
return Triple("x86_64-apple-darwin");
|
|
|
|
case MachO::CPU_SUBTYPE_X86_64_H:
|
|
|
|
return Triple("x86_64h-apple-darwin");
|
|
|
|
default:
|
|
|
|
return Triple();
|
|
|
|
}
|
|
|
|
case MachO::CPU_TYPE_ARM:
|
|
|
|
switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
|
|
|
|
case MachO::CPU_SUBTYPE_ARM_V4T:
|
|
|
|
return Triple("armv4t-apple-darwin");
|
|
|
|
case MachO::CPU_SUBTYPE_ARM_V5TEJ:
|
|
|
|
return Triple("armv5e-apple-darwin");
|
2014-08-08 05:30:25 +08:00
|
|
|
case MachO::CPU_SUBTYPE_ARM_XSCALE:
|
|
|
|
return Triple("xscale-apple-darwin");
|
2014-07-01 02:45:23 +08:00
|
|
|
case MachO::CPU_SUBTYPE_ARM_V6:
|
|
|
|
return Triple("armv6-apple-darwin");
|
|
|
|
case MachO::CPU_SUBTYPE_ARM_V6M:
|
2014-08-19 04:21:02 +08:00
|
|
|
if (McpuDefault)
|
|
|
|
*McpuDefault = "cortex-m0";
|
2014-07-01 02:45:23 +08:00
|
|
|
return Triple("armv6m-apple-darwin");
|
2014-08-08 05:30:25 +08:00
|
|
|
case MachO::CPU_SUBTYPE_ARM_V7:
|
|
|
|
return Triple("armv7-apple-darwin");
|
2014-07-01 02:45:23 +08:00
|
|
|
case MachO::CPU_SUBTYPE_ARM_V7EM:
|
2014-08-19 04:21:02 +08:00
|
|
|
if (McpuDefault)
|
|
|
|
*McpuDefault = "cortex-m4";
|
2016-04-23 07:21:13 +08:00
|
|
|
return Triple("thumbv7em-apple-darwin");
|
2014-07-01 02:45:23 +08:00
|
|
|
case MachO::CPU_SUBTYPE_ARM_V7K:
|
|
|
|
return Triple("armv7k-apple-darwin");
|
|
|
|
case MachO::CPU_SUBTYPE_ARM_V7M:
|
2014-08-19 04:21:02 +08:00
|
|
|
if (McpuDefault)
|
|
|
|
*McpuDefault = "cortex-m3";
|
2016-04-23 07:21:13 +08:00
|
|
|
return Triple("thumbv7m-apple-darwin");
|
2014-07-01 02:45:23 +08:00
|
|
|
case MachO::CPU_SUBTYPE_ARM_V7S:
|
|
|
|
return Triple("armv7s-apple-darwin");
|
|
|
|
default:
|
|
|
|
return Triple();
|
|
|
|
}
|
|
|
|
case MachO::CPU_TYPE_ARM64:
|
|
|
|
switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
|
|
|
|
case MachO::CPU_SUBTYPE_ARM64_ALL:
|
|
|
|
return Triple("arm64-apple-darwin");
|
|
|
|
default:
|
|
|
|
return Triple();
|
|
|
|
}
|
|
|
|
case MachO::CPU_TYPE_POWERPC:
|
|
|
|
switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
|
|
|
|
case MachO::CPU_SUBTYPE_POWERPC_ALL:
|
|
|
|
return Triple("ppc-apple-darwin");
|
|
|
|
default:
|
|
|
|
return Triple();
|
|
|
|
}
|
|
|
|
case MachO::CPU_TYPE_POWERPC64:
|
2014-07-01 04:12:59 +08:00
|
|
|
switch (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) {
|
2014-07-01 02:45:23 +08:00
|
|
|
case MachO::CPU_SUBTYPE_POWERPC_ALL:
|
|
|
|
return Triple("ppc64-apple-darwin");
|
|
|
|
default:
|
|
|
|
return Triple();
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
return Triple();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Triple MachOObjectFile::getHostArch() {
|
|
|
|
return Triple(sys::getDefaultTargetTriple());
|
|
|
|
}
|
|
|
|
|
2014-08-09 00:30:17 +08:00
|
|
|
bool MachOObjectFile::isValidArch(StringRef ArchFlag) {
|
|
|
|
return StringSwitch<bool>(ArchFlag)
|
|
|
|
.Case("i386", true)
|
|
|
|
.Case("x86_64", true)
|
|
|
|
.Case("x86_64h", true)
|
|
|
|
.Case("armv4t", true)
|
|
|
|
.Case("arm", true)
|
|
|
|
.Case("armv5e", true)
|
|
|
|
.Case("armv6", true)
|
|
|
|
.Case("armv6m", true)
|
2015-06-17 01:37:03 +08:00
|
|
|
.Case("armv7", true)
|
2014-08-09 00:30:17 +08:00
|
|
|
.Case("armv7em", true)
|
|
|
|
.Case("armv7k", true)
|
|
|
|
.Case("armv7m", true)
|
|
|
|
.Case("armv7s", true)
|
|
|
|
.Case("arm64", true)
|
|
|
|
.Case("ppc", true)
|
|
|
|
.Case("ppc64", true)
|
|
|
|
.Default(false);
|
2014-07-01 02:45:23 +08:00
|
|
|
}
|
|
|
|
|
2013-06-18 23:03:28 +08:00
|
|
|
unsigned MachOObjectFile::getArch() const {
|
|
|
|
return getArch(getCPUType(this));
|
|
|
|
}
|
|
|
|
|
2016-04-23 07:21:13 +08:00
|
|
|
Triple MachOObjectFile::getArchTriple(const char **McpuDefault) const {
|
|
|
|
return getArchTriple(Header.cputype, Header.cpusubtype, McpuDefault);
|
2014-08-19 04:21:02 +08:00
|
|
|
}
|
|
|
|
|
2013-09-28 05:47:05 +08:00
|
|
|
relocation_iterator MachOObjectFile::section_rel_begin(unsigned Index) const {
|
2013-04-27 04:07:33 +08:00
|
|
|
DataRefImpl DRI;
|
|
|
|
DRI.d.a = Index;
|
2013-09-28 05:47:05 +08:00
|
|
|
return section_rel_begin(DRI);
|
2013-04-27 04:07:33 +08:00
|
|
|
}
|
|
|
|
|
2013-09-28 05:47:05 +08:00
|
|
|
relocation_iterator MachOObjectFile::section_rel_end(unsigned Index) const {
|
2013-04-27 04:07:33 +08:00
|
|
|
DataRefImpl DRI;
|
|
|
|
DRI.d.a = Index;
|
2013-09-28 05:47:05 +08:00
|
|
|
return section_rel_end(DRI);
|
2013-04-27 04:07:33 +08:00
|
|
|
}
|
|
|
|
|
2013-06-07 01:20:50 +08:00
|
|
|
dice_iterator MachOObjectFile::begin_dices() const {
|
|
|
|
DataRefImpl DRI;
|
|
|
|
if (!DataInCodeLoadCmd)
|
|
|
|
return dice_iterator(DiceRef(DRI, this));
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
|
|
|
|
DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, DicLC.dataoff));
|
2013-06-07 01:20:50 +08:00
|
|
|
return dice_iterator(DiceRef(DRI, this));
|
|
|
|
}
|
|
|
|
|
|
|
|
dice_iterator MachOObjectFile::end_dices() const {
|
|
|
|
DataRefImpl DRI;
|
|
|
|
if (!DataInCodeLoadCmd)
|
|
|
|
return dice_iterator(DiceRef(DRI, this));
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
|
|
|
|
unsigned Offset = DicLC.dataoff + DicLC.datasize;
|
2013-06-07 01:20:50 +08:00
|
|
|
DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset));
|
|
|
|
return dice_iterator(DiceRef(DRI, this));
|
|
|
|
}
|
|
|
|
|
2015-09-22 19:13:55 +08:00
|
|
|
ExportEntry::ExportEntry(ArrayRef<uint8_t> T)
|
|
|
|
: Trie(T), Malformed(false), Done(false) {}
|
2014-08-30 08:20:14 +08:00
|
|
|
|
|
|
|
void ExportEntry::moveToFirst() {
|
|
|
|
pushNode(0);
|
|
|
|
pushDownUntilBottom();
|
|
|
|
}
|
|
|
|
|
|
|
|
void ExportEntry::moveToEnd() {
|
|
|
|
Stack.clear();
|
|
|
|
Done = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ExportEntry::operator==(const ExportEntry &Other) const {
|
2015-09-22 19:14:12 +08:00
|
|
|
// Common case, one at end, other iterating from begin.
|
2014-08-30 08:20:14 +08:00
|
|
|
if (Done || Other.Done)
|
|
|
|
return (Done == Other.Done);
|
|
|
|
// Not equal if different stack sizes.
|
|
|
|
if (Stack.size() != Other.Stack.size())
|
|
|
|
return false;
|
|
|
|
// Not equal if different cumulative strings.
|
2015-03-30 23:42:36 +08:00
|
|
|
if (!CumulativeString.equals(Other.CumulativeString))
|
2014-08-30 08:20:14 +08:00
|
|
|
return false;
|
|
|
|
// Equal if all nodes in both stacks match.
|
|
|
|
for (unsigned i=0; i < Stack.size(); ++i) {
|
|
|
|
if (Stack[i].Start != Other.Stack[i].Start)
|
|
|
|
return false;
|
|
|
|
}
|
2015-09-22 19:19:03 +08:00
|
|
|
return true;
|
2014-08-30 08:20:14 +08:00
|
|
|
}
|
|
|
|
|
2014-09-03 02:50:24 +08:00
|
|
|
uint64_t ExportEntry::readULEB128(const uint8_t *&Ptr) {
|
|
|
|
unsigned Count;
|
|
|
|
uint64_t Result = decodeULEB128(Ptr, &Count);
|
|
|
|
Ptr += Count;
|
|
|
|
if (Ptr > Trie.end()) {
|
|
|
|
Ptr = Trie.end();
|
2014-08-30 08:20:14 +08:00
|
|
|
Malformed = true;
|
|
|
|
}
|
2014-09-03 02:50:24 +08:00
|
|
|
return Result;
|
2014-08-30 08:20:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
StringRef ExportEntry::name() const {
|
2015-03-30 23:42:36 +08:00
|
|
|
return CumulativeString;
|
2014-08-30 08:20:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t ExportEntry::flags() const {
|
|
|
|
return Stack.back().Flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t ExportEntry::address() const {
|
|
|
|
return Stack.back().Address;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t ExportEntry::other() const {
|
|
|
|
return Stack.back().Other;
|
|
|
|
}
|
|
|
|
|
|
|
|
StringRef ExportEntry::otherName() const {
|
|
|
|
const char* ImportName = Stack.back().ImportName;
|
|
|
|
if (ImportName)
|
|
|
|
return StringRef(ImportName);
|
|
|
|
return StringRef();
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t ExportEntry::nodeOffset() const {
|
|
|
|
return Stack.back().Start - Trie.begin();
|
|
|
|
}
|
|
|
|
|
2015-09-22 19:13:55 +08:00
|
|
|
ExportEntry::NodeState::NodeState(const uint8_t *Ptr)
|
|
|
|
: Start(Ptr), Current(Ptr), Flags(0), Address(0), Other(0),
|
|
|
|
ImportName(nullptr), ChildCount(0), NextChildIndex(0),
|
|
|
|
ParentStringLength(0), IsExportNode(false) {}
|
2014-08-30 08:20:14 +08:00
|
|
|
|
|
|
|
void ExportEntry::pushNode(uint64_t offset) {
|
|
|
|
const uint8_t *Ptr = Trie.begin() + offset;
|
|
|
|
NodeState State(Ptr);
|
|
|
|
uint64_t ExportInfoSize = readULEB128(State.Current);
|
|
|
|
State.IsExportNode = (ExportInfoSize != 0);
|
|
|
|
const uint8_t* Children = State.Current + ExportInfoSize;
|
|
|
|
if (State.IsExportNode) {
|
|
|
|
State.Flags = readULEB128(State.Current);
|
|
|
|
if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) {
|
|
|
|
State.Address = 0;
|
|
|
|
State.Other = readULEB128(State.Current); // dylib ordinal
|
|
|
|
State.ImportName = reinterpret_cast<const char*>(State.Current);
|
|
|
|
} else {
|
|
|
|
State.Address = readULEB128(State.Current);
|
2014-08-30 09:57:34 +08:00
|
|
|
if (State.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER)
|
2015-09-22 19:19:03 +08:00
|
|
|
State.Other = readULEB128(State.Current);
|
2014-08-30 08:20:14 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
State.ChildCount = *Children;
|
|
|
|
State.Current = Children + 1;
|
|
|
|
State.NextChildIndex = 0;
|
|
|
|
State.ParentStringLength = CumulativeString.size();
|
|
|
|
Stack.push_back(State);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ExportEntry::pushDownUntilBottom() {
|
|
|
|
while (Stack.back().NextChildIndex < Stack.back().ChildCount) {
|
|
|
|
NodeState &Top = Stack.back();
|
|
|
|
CumulativeString.resize(Top.ParentStringLength);
|
|
|
|
for (;*Top.Current != 0; Top.Current++) {
|
2014-09-03 02:50:24 +08:00
|
|
|
char C = *Top.Current;
|
|
|
|
CumulativeString.push_back(C);
|
2014-08-30 08:20:14 +08:00
|
|
|
}
|
|
|
|
Top.Current += 1;
|
|
|
|
uint64_t childNodeIndex = readULEB128(Top.Current);
|
|
|
|
Top.NextChildIndex += 1;
|
|
|
|
pushNode(childNodeIndex);
|
|
|
|
}
|
|
|
|
if (!Stack.back().IsExportNode) {
|
|
|
|
Malformed = true;
|
|
|
|
moveToEnd();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// We have a trie data structure and need a way to walk it that is compatible
|
|
|
|
// with the C++ iterator model. The solution is a non-recursive depth first
|
|
|
|
// traversal where the iterator contains a stack of parent nodes along with a
|
|
|
|
// string that is the accumulation of all edge strings along the parent chain
|
|
|
|
// to this point.
|
|
|
|
//
|
2014-10-27 16:08:18 +08:00
|
|
|
// There is one "export" node for each exported symbol. But because some
|
2014-08-30 08:20:14 +08:00
|
|
|
// symbols may be a prefix of another symbol (e.g. _dup and _dup2), an export
|
2015-09-22 19:14:12 +08:00
|
|
|
// node may have child nodes too.
|
2014-08-30 08:20:14 +08:00
|
|
|
//
|
|
|
|
// The algorithm for moveNext() is to keep moving down the leftmost unvisited
|
|
|
|
// child until hitting a node with no children (which is an export node or
|
|
|
|
// else the trie is malformed). On the way down, each node is pushed on the
|
|
|
|
// stack ivar. If there is no more ways down, it pops up one and tries to go
|
|
|
|
// down a sibling path until a childless node is reached.
|
|
|
|
void ExportEntry::moveNext() {
|
|
|
|
if (Stack.empty() || !Stack.back().IsExportNode) {
|
|
|
|
Malformed = true;
|
|
|
|
moveToEnd();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
Stack.pop_back();
|
|
|
|
while (!Stack.empty()) {
|
|
|
|
NodeState &Top = Stack.back();
|
|
|
|
if (Top.NextChildIndex < Top.ChildCount) {
|
|
|
|
pushDownUntilBottom();
|
|
|
|
// Now at the next export node.
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
if (Top.IsExportNode) {
|
|
|
|
// This node has no children but is itself an export node.
|
|
|
|
CumulativeString.resize(Top.ParentStringLength);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
Stack.pop_back();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Done = true;
|
|
|
|
}
|
|
|
|
|
2015-09-22 19:19:03 +08:00
|
|
|
iterator_range<export_iterator>
|
2014-08-30 08:20:14 +08:00
|
|
|
MachOObjectFile::exports(ArrayRef<uint8_t> Trie) {
|
|
|
|
ExportEntry Start(Trie);
|
2014-12-19 10:31:01 +08:00
|
|
|
if (Trie.size() == 0)
|
|
|
|
Start.moveToEnd();
|
|
|
|
else
|
|
|
|
Start.moveToFirst();
|
2014-08-30 08:20:14 +08:00
|
|
|
|
|
|
|
ExportEntry Finish(Trie);
|
|
|
|
Finish.moveToEnd();
|
|
|
|
|
2015-12-06 13:08:07 +08:00
|
|
|
return make_range(export_iterator(Start), export_iterator(Finish));
|
2014-08-30 08:20:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
iterator_range<export_iterator> MachOObjectFile::exports() const {
|
|
|
|
return exports(getDyldInfoExportsTrie());
|
|
|
|
}
|
|
|
|
|
2014-09-13 05:34:15 +08:00
|
|
|
MachORebaseEntry::MachORebaseEntry(ArrayRef<uint8_t> Bytes, bool is64Bit)
|
|
|
|
: Opcodes(Bytes), Ptr(Bytes.begin()), SegmentOffset(0), SegmentIndex(0),
|
|
|
|
RemainingLoopCount(0), AdvanceAmount(0), RebaseType(0),
|
|
|
|
PointerSize(is64Bit ? 8 : 4), Malformed(false), Done(false) {}
|
|
|
|
|
|
|
|
void MachORebaseEntry::moveToFirst() {
|
|
|
|
Ptr = Opcodes.begin();
|
|
|
|
moveNext();
|
|
|
|
}
|
|
|
|
|
|
|
|
void MachORebaseEntry::moveToEnd() {
|
|
|
|
Ptr = Opcodes.end();
|
|
|
|
RemainingLoopCount = 0;
|
|
|
|
Done = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MachORebaseEntry::moveNext() {
|
|
|
|
// If in the middle of some loop, move to next rebasing in loop.
|
|
|
|
SegmentOffset += AdvanceAmount;
|
|
|
|
if (RemainingLoopCount) {
|
|
|
|
--RemainingLoopCount;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (Ptr == Opcodes.end()) {
|
|
|
|
Done = true;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
bool More = true;
|
|
|
|
while (More && !Malformed) {
|
|
|
|
// Parse next opcode and set up next loop.
|
|
|
|
uint8_t Byte = *Ptr++;
|
|
|
|
uint8_t ImmValue = Byte & MachO::REBASE_IMMEDIATE_MASK;
|
|
|
|
uint8_t Opcode = Byte & MachO::REBASE_OPCODE_MASK;
|
|
|
|
switch (Opcode) {
|
|
|
|
case MachO::REBASE_OPCODE_DONE:
|
|
|
|
More = false;
|
|
|
|
Done = true;
|
|
|
|
moveToEnd();
|
|
|
|
DEBUG_WITH_TYPE("mach-o-rebase", llvm::dbgs() << "REBASE_OPCODE_DONE\n");
|
|
|
|
break;
|
|
|
|
case MachO::REBASE_OPCODE_SET_TYPE_IMM:
|
|
|
|
RebaseType = ImmValue;
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-rebase",
|
|
|
|
llvm::dbgs() << "REBASE_OPCODE_SET_TYPE_IMM: "
|
|
|
|
<< "RebaseType=" << (int) RebaseType << "\n");
|
|
|
|
break;
|
|
|
|
case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
|
|
|
|
SegmentIndex = ImmValue;
|
|
|
|
SegmentOffset = readULEB128();
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-rebase",
|
|
|
|
llvm::dbgs() << "REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
|
|
|
|
<< "SegmentIndex=" << SegmentIndex << ", "
|
|
|
|
<< format("SegmentOffset=0x%06X", SegmentOffset)
|
|
|
|
<< "\n");
|
|
|
|
break;
|
|
|
|
case MachO::REBASE_OPCODE_ADD_ADDR_ULEB:
|
|
|
|
SegmentOffset += readULEB128();
|
|
|
|
DEBUG_WITH_TYPE("mach-o-rebase",
|
|
|
|
llvm::dbgs() << "REBASE_OPCODE_ADD_ADDR_ULEB: "
|
|
|
|
<< format("SegmentOffset=0x%06X",
|
|
|
|
SegmentOffset) << "\n");
|
|
|
|
break;
|
|
|
|
case MachO::REBASE_OPCODE_ADD_ADDR_IMM_SCALED:
|
|
|
|
SegmentOffset += ImmValue * PointerSize;
|
|
|
|
DEBUG_WITH_TYPE("mach-o-rebase",
|
|
|
|
llvm::dbgs() << "REBASE_OPCODE_ADD_ADDR_IMM_SCALED: "
|
|
|
|
<< format("SegmentOffset=0x%06X",
|
|
|
|
SegmentOffset) << "\n");
|
|
|
|
break;
|
|
|
|
case MachO::REBASE_OPCODE_DO_REBASE_IMM_TIMES:
|
|
|
|
AdvanceAmount = PointerSize;
|
|
|
|
RemainingLoopCount = ImmValue - 1;
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-rebase",
|
|
|
|
llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_IMM_TIMES: "
|
|
|
|
<< format("SegmentOffset=0x%06X", SegmentOffset)
|
|
|
|
<< ", AdvanceAmount=" << AdvanceAmount
|
|
|
|
<< ", RemainingLoopCount=" << RemainingLoopCount
|
|
|
|
<< "\n");
|
|
|
|
return;
|
|
|
|
case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES:
|
|
|
|
AdvanceAmount = PointerSize;
|
|
|
|
RemainingLoopCount = readULEB128() - 1;
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-rebase",
|
|
|
|
llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES: "
|
|
|
|
<< format("SegmentOffset=0x%06X", SegmentOffset)
|
|
|
|
<< ", AdvanceAmount=" << AdvanceAmount
|
|
|
|
<< ", RemainingLoopCount=" << RemainingLoopCount
|
|
|
|
<< "\n");
|
|
|
|
return;
|
|
|
|
case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:
|
|
|
|
AdvanceAmount = readULEB128() + PointerSize;
|
|
|
|
RemainingLoopCount = 0;
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-rebase",
|
|
|
|
llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: "
|
|
|
|
<< format("SegmentOffset=0x%06X", SegmentOffset)
|
|
|
|
<< ", AdvanceAmount=" << AdvanceAmount
|
|
|
|
<< ", RemainingLoopCount=" << RemainingLoopCount
|
|
|
|
<< "\n");
|
|
|
|
return;
|
|
|
|
case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:
|
|
|
|
RemainingLoopCount = readULEB128() - 1;
|
|
|
|
AdvanceAmount = readULEB128() + PointerSize;
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-rebase",
|
|
|
|
llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: "
|
|
|
|
<< format("SegmentOffset=0x%06X", SegmentOffset)
|
|
|
|
<< ", AdvanceAmount=" << AdvanceAmount
|
|
|
|
<< ", RemainingLoopCount=" << RemainingLoopCount
|
|
|
|
<< "\n");
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
Malformed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t MachORebaseEntry::readULEB128() {
|
|
|
|
unsigned Count;
|
|
|
|
uint64_t Result = decodeULEB128(Ptr, &Count);
|
|
|
|
Ptr += Count;
|
|
|
|
if (Ptr > Opcodes.end()) {
|
|
|
|
Ptr = Opcodes.end();
|
|
|
|
Malformed = true;
|
|
|
|
}
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t MachORebaseEntry::segmentIndex() const { return SegmentIndex; }
|
|
|
|
|
|
|
|
uint64_t MachORebaseEntry::segmentOffset() const { return SegmentOffset; }
|
|
|
|
|
|
|
|
StringRef MachORebaseEntry::typeName() const {
|
|
|
|
switch (RebaseType) {
|
|
|
|
case MachO::REBASE_TYPE_POINTER:
|
|
|
|
return "pointer";
|
|
|
|
case MachO::REBASE_TYPE_TEXT_ABSOLUTE32:
|
|
|
|
return "text abs32";
|
|
|
|
case MachO::REBASE_TYPE_TEXT_PCREL32:
|
|
|
|
return "text rel32";
|
|
|
|
}
|
|
|
|
return "unknown";
|
|
|
|
}
|
|
|
|
|
|
|
|
bool MachORebaseEntry::operator==(const MachORebaseEntry &Other) const {
|
|
|
|
assert(Opcodes == Other.Opcodes && "compare iterators of different files");
|
|
|
|
return (Ptr == Other.Ptr) &&
|
|
|
|
(RemainingLoopCount == Other.RemainingLoopCount) &&
|
|
|
|
(Done == Other.Done);
|
|
|
|
}
|
|
|
|
|
|
|
|
iterator_range<rebase_iterator>
|
|
|
|
MachOObjectFile::rebaseTable(ArrayRef<uint8_t> Opcodes, bool is64) {
|
|
|
|
MachORebaseEntry Start(Opcodes, is64);
|
|
|
|
Start.moveToFirst();
|
|
|
|
|
|
|
|
MachORebaseEntry Finish(Opcodes, is64);
|
|
|
|
Finish.moveToEnd();
|
|
|
|
|
2015-12-06 13:08:07 +08:00
|
|
|
return make_range(rebase_iterator(Start), rebase_iterator(Finish));
|
2014-09-13 05:34:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
iterator_range<rebase_iterator> MachOObjectFile::rebaseTable() const {
|
|
|
|
return rebaseTable(getDyldInfoRebaseOpcodes(), is64Bit());
|
|
|
|
}
|
|
|
|
|
2015-09-22 19:13:55 +08:00
|
|
|
MachOBindEntry::MachOBindEntry(ArrayRef<uint8_t> Bytes, bool is64Bit, Kind BK)
|
2014-09-16 09:41:51 +08:00
|
|
|
: Opcodes(Bytes), Ptr(Bytes.begin()), SegmentOffset(0), SegmentIndex(0),
|
|
|
|
Ordinal(0), Flags(0), Addend(0), RemainingLoopCount(0), AdvanceAmount(0),
|
|
|
|
BindType(0), PointerSize(is64Bit ? 8 : 4),
|
|
|
|
TableKind(BK), Malformed(false), Done(false) {}
|
|
|
|
|
|
|
|
void MachOBindEntry::moveToFirst() {
|
|
|
|
Ptr = Opcodes.begin();
|
|
|
|
moveNext();
|
|
|
|
}
|
|
|
|
|
|
|
|
void MachOBindEntry::moveToEnd() {
|
|
|
|
Ptr = Opcodes.end();
|
|
|
|
RemainingLoopCount = 0;
|
|
|
|
Done = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MachOBindEntry::moveNext() {
|
|
|
|
// If in the middle of some loop, move to next binding in loop.
|
|
|
|
SegmentOffset += AdvanceAmount;
|
|
|
|
if (RemainingLoopCount) {
|
|
|
|
--RemainingLoopCount;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (Ptr == Opcodes.end()) {
|
|
|
|
Done = true;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
bool More = true;
|
|
|
|
while (More && !Malformed) {
|
|
|
|
// Parse next opcode and set up next loop.
|
|
|
|
uint8_t Byte = *Ptr++;
|
|
|
|
uint8_t ImmValue = Byte & MachO::BIND_IMMEDIATE_MASK;
|
|
|
|
uint8_t Opcode = Byte & MachO::BIND_OPCODE_MASK;
|
|
|
|
int8_t SignExtended;
|
|
|
|
const uint8_t *SymStart;
|
|
|
|
switch (Opcode) {
|
|
|
|
case MachO::BIND_OPCODE_DONE:
|
|
|
|
if (TableKind == Kind::Lazy) {
|
|
|
|
// Lazying bindings have a DONE opcode between entries. Need to ignore
|
|
|
|
// it to advance to next entry. But need not if this is last entry.
|
|
|
|
bool NotLastEntry = false;
|
|
|
|
for (const uint8_t *P = Ptr; P < Opcodes.end(); ++P) {
|
|
|
|
if (*P) {
|
|
|
|
NotLastEntry = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (NotLastEntry)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
More = false;
|
|
|
|
Done = true;
|
|
|
|
moveToEnd();
|
|
|
|
DEBUG_WITH_TYPE("mach-o-bind", llvm::dbgs() << "BIND_OPCODE_DONE\n");
|
|
|
|
break;
|
|
|
|
case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
|
|
|
|
Ordinal = ImmValue;
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-bind",
|
|
|
|
llvm::dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: "
|
|
|
|
<< "Ordinal=" << Ordinal << "\n");
|
|
|
|
break;
|
|
|
|
case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
|
|
|
|
Ordinal = readULEB128();
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-bind",
|
|
|
|
llvm::dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: "
|
|
|
|
<< "Ordinal=" << Ordinal << "\n");
|
|
|
|
break;
|
|
|
|
case MachO::BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
|
|
|
|
if (ImmValue) {
|
|
|
|
SignExtended = MachO::BIND_OPCODE_MASK | ImmValue;
|
|
|
|
Ordinal = SignExtended;
|
|
|
|
} else
|
|
|
|
Ordinal = 0;
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-bind",
|
|
|
|
llvm::dbgs() << "BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: "
|
|
|
|
<< "Ordinal=" << Ordinal << "\n");
|
|
|
|
break;
|
|
|
|
case MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
|
|
|
|
Flags = ImmValue;
|
|
|
|
SymStart = Ptr;
|
|
|
|
while (*Ptr) {
|
|
|
|
++Ptr;
|
|
|
|
}
|
|
|
|
SymbolName = StringRef(reinterpret_cast<const char*>(SymStart),
|
|
|
|
Ptr-SymStart);
|
2014-09-17 09:51:43 +08:00
|
|
|
++Ptr;
|
2014-09-16 09:41:51 +08:00
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-bind",
|
|
|
|
llvm::dbgs() << "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: "
|
|
|
|
<< "SymbolName=" << SymbolName << "\n");
|
|
|
|
if (TableKind == Kind::Weak) {
|
|
|
|
if (ImmValue & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case MachO::BIND_OPCODE_SET_TYPE_IMM:
|
|
|
|
BindType = ImmValue;
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-bind",
|
|
|
|
llvm::dbgs() << "BIND_OPCODE_SET_TYPE_IMM: "
|
|
|
|
<< "BindType=" << (int)BindType << "\n");
|
|
|
|
break;
|
|
|
|
case MachO::BIND_OPCODE_SET_ADDEND_SLEB:
|
|
|
|
Addend = readSLEB128();
|
|
|
|
if (TableKind == Kind::Lazy)
|
|
|
|
Malformed = true;
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-bind",
|
|
|
|
llvm::dbgs() << "BIND_OPCODE_SET_ADDEND_SLEB: "
|
|
|
|
<< "Addend=" << Addend << "\n");
|
|
|
|
break;
|
|
|
|
case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
|
|
|
|
SegmentIndex = ImmValue;
|
|
|
|
SegmentOffset = readULEB128();
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-bind",
|
|
|
|
llvm::dbgs() << "BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
|
|
|
|
<< "SegmentIndex=" << SegmentIndex << ", "
|
|
|
|
<< format("SegmentOffset=0x%06X", SegmentOffset)
|
|
|
|
<< "\n");
|
|
|
|
break;
|
|
|
|
case MachO::BIND_OPCODE_ADD_ADDR_ULEB:
|
|
|
|
SegmentOffset += readULEB128();
|
|
|
|
DEBUG_WITH_TYPE("mach-o-bind",
|
|
|
|
llvm::dbgs() << "BIND_OPCODE_ADD_ADDR_ULEB: "
|
|
|
|
<< format("SegmentOffset=0x%06X",
|
|
|
|
SegmentOffset) << "\n");
|
|
|
|
break;
|
|
|
|
case MachO::BIND_OPCODE_DO_BIND:
|
|
|
|
AdvanceAmount = PointerSize;
|
|
|
|
RemainingLoopCount = 0;
|
|
|
|
DEBUG_WITH_TYPE("mach-o-bind",
|
|
|
|
llvm::dbgs() << "BIND_OPCODE_DO_BIND: "
|
|
|
|
<< format("SegmentOffset=0x%06X",
|
|
|
|
SegmentOffset) << "\n");
|
|
|
|
return;
|
|
|
|
case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
|
2014-10-18 09:21:02 +08:00
|
|
|
AdvanceAmount = readULEB128() + PointerSize;
|
2014-09-16 09:41:51 +08:00
|
|
|
RemainingLoopCount = 0;
|
|
|
|
if (TableKind == Kind::Lazy)
|
|
|
|
Malformed = true;
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-bind",
|
2014-10-18 09:21:02 +08:00
|
|
|
llvm::dbgs() << "BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: "
|
2014-09-16 09:41:51 +08:00
|
|
|
<< format("SegmentOffset=0x%06X", SegmentOffset)
|
|
|
|
<< ", AdvanceAmount=" << AdvanceAmount
|
|
|
|
<< ", RemainingLoopCount=" << RemainingLoopCount
|
|
|
|
<< "\n");
|
|
|
|
return;
|
|
|
|
case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
|
2014-10-18 09:21:02 +08:00
|
|
|
AdvanceAmount = ImmValue * PointerSize + PointerSize;
|
2014-09-16 09:41:51 +08:00
|
|
|
RemainingLoopCount = 0;
|
|
|
|
if (TableKind == Kind::Lazy)
|
|
|
|
Malformed = true;
|
|
|
|
DEBUG_WITH_TYPE("mach-o-bind",
|
|
|
|
llvm::dbgs()
|
|
|
|
<< "BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: "
|
|
|
|
<< format("SegmentOffset=0x%06X",
|
|
|
|
SegmentOffset) << "\n");
|
|
|
|
return;
|
|
|
|
case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
|
|
|
|
RemainingLoopCount = readULEB128() - 1;
|
|
|
|
AdvanceAmount = readULEB128() + PointerSize;
|
|
|
|
if (TableKind == Kind::Lazy)
|
|
|
|
Malformed = true;
|
|
|
|
DEBUG_WITH_TYPE(
|
|
|
|
"mach-o-bind",
|
|
|
|
llvm::dbgs() << "BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: "
|
|
|
|
<< format("SegmentOffset=0x%06X", SegmentOffset)
|
|
|
|
<< ", AdvanceAmount=" << AdvanceAmount
|
|
|
|
<< ", RemainingLoopCount=" << RemainingLoopCount
|
|
|
|
<< "\n");
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
Malformed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t MachOBindEntry::readULEB128() {
|
|
|
|
unsigned Count;
|
|
|
|
uint64_t Result = decodeULEB128(Ptr, &Count);
|
|
|
|
Ptr += Count;
|
|
|
|
if (Ptr > Opcodes.end()) {
|
|
|
|
Ptr = Opcodes.end();
|
|
|
|
Malformed = true;
|
|
|
|
}
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
int64_t MachOBindEntry::readSLEB128() {
|
|
|
|
unsigned Count;
|
|
|
|
int64_t Result = decodeSLEB128(Ptr, &Count);
|
|
|
|
Ptr += Count;
|
|
|
|
if (Ptr > Opcodes.end()) {
|
|
|
|
Ptr = Opcodes.end();
|
|
|
|
Malformed = true;
|
|
|
|
}
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t MachOBindEntry::segmentIndex() const { return SegmentIndex; }
|
|
|
|
|
|
|
|
uint64_t MachOBindEntry::segmentOffset() const { return SegmentOffset; }
|
|
|
|
|
|
|
|
StringRef MachOBindEntry::typeName() const {
|
|
|
|
switch (BindType) {
|
|
|
|
case MachO::BIND_TYPE_POINTER:
|
|
|
|
return "pointer";
|
|
|
|
case MachO::BIND_TYPE_TEXT_ABSOLUTE32:
|
|
|
|
return "text abs32";
|
|
|
|
case MachO::BIND_TYPE_TEXT_PCREL32:
|
|
|
|
return "text rel32";
|
|
|
|
}
|
|
|
|
return "unknown";
|
|
|
|
}
|
|
|
|
|
|
|
|
StringRef MachOBindEntry::symbolName() const { return SymbolName; }
|
|
|
|
|
|
|
|
int64_t MachOBindEntry::addend() const { return Addend; }
|
|
|
|
|
|
|
|
uint32_t MachOBindEntry::flags() const { return Flags; }
|
|
|
|
|
|
|
|
int MachOBindEntry::ordinal() const { return Ordinal; }
|
|
|
|
|
|
|
|
bool MachOBindEntry::operator==(const MachOBindEntry &Other) const {
|
|
|
|
assert(Opcodes == Other.Opcodes && "compare iterators of different files");
|
|
|
|
return (Ptr == Other.Ptr) &&
|
|
|
|
(RemainingLoopCount == Other.RemainingLoopCount) &&
|
|
|
|
(Done == Other.Done);
|
|
|
|
}
|
|
|
|
|
|
|
|
iterator_range<bind_iterator>
|
|
|
|
MachOObjectFile::bindTable(ArrayRef<uint8_t> Opcodes, bool is64,
|
|
|
|
MachOBindEntry::Kind BKind) {
|
|
|
|
MachOBindEntry Start(Opcodes, is64, BKind);
|
|
|
|
Start.moveToFirst();
|
|
|
|
|
|
|
|
MachOBindEntry Finish(Opcodes, is64, BKind);
|
|
|
|
Finish.moveToEnd();
|
|
|
|
|
2015-12-06 13:08:07 +08:00
|
|
|
return make_range(bind_iterator(Start), bind_iterator(Finish));
|
2014-09-16 09:41:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
iterator_range<bind_iterator> MachOObjectFile::bindTable() const {
|
|
|
|
return bindTable(getDyldInfoBindOpcodes(), is64Bit(),
|
|
|
|
MachOBindEntry::Kind::Regular);
|
|
|
|
}
|
|
|
|
|
|
|
|
iterator_range<bind_iterator> MachOObjectFile::lazyBindTable() const {
|
|
|
|
return bindTable(getDyldInfoLazyBindOpcodes(), is64Bit(),
|
|
|
|
MachOBindEntry::Kind::Lazy);
|
|
|
|
}
|
|
|
|
|
|
|
|
iterator_range<bind_iterator> MachOObjectFile::weakBindTable() const {
|
|
|
|
return bindTable(getDyldInfoWeakBindOpcodes(), is64Bit(),
|
|
|
|
MachOBindEntry::Kind::Weak);
|
|
|
|
}
|
|
|
|
|
2015-06-04 06:19:36 +08:00
|
|
|
MachOObjectFile::load_command_iterator
|
|
|
|
MachOObjectFile::begin_load_commands() const {
|
|
|
|
return LoadCommands.begin();
|
|
|
|
}
|
|
|
|
|
|
|
|
MachOObjectFile::load_command_iterator
|
|
|
|
MachOObjectFile::end_load_commands() const {
|
|
|
|
return LoadCommands.end();
|
|
|
|
}
|
|
|
|
|
|
|
|
iterator_range<MachOObjectFile::load_command_iterator>
|
|
|
|
MachOObjectFile::load_commands() const {
|
2015-12-06 13:08:07 +08:00
|
|
|
return make_range(begin_load_commands(), end_load_commands());
|
2015-06-04 06:19:36 +08:00
|
|
|
}
|
|
|
|
|
2013-04-19 02:08:55 +08:00
|
|
|
StringRef
|
|
|
|
MachOObjectFile::getSectionFinalSegmentName(DataRefImpl Sec) const {
|
|
|
|
ArrayRef<char> Raw = getSectionRawFinalSegmentName(Sec);
|
|
|
|
return parseSegmentOrSectionName(Raw.data());
|
|
|
|
}
|
|
|
|
|
|
|
|
ArrayRef<char>
|
|
|
|
MachOObjectFile::getSectionRawName(DataRefImpl Sec) const {
|
2015-05-22 22:59:27 +08:00
|
|
|
assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
|
2013-09-01 12:28:48 +08:00
|
|
|
const section_base *Base =
|
|
|
|
reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
|
2014-08-27 13:25:25 +08:00
|
|
|
return makeArrayRef(Base->sectname);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ArrayRef<char>
|
|
|
|
MachOObjectFile::getSectionRawFinalSegmentName(DataRefImpl Sec) const {
|
2015-05-22 22:59:27 +08:00
|
|
|
assert(Sec.d.a < Sections.size() && "Should have detected this earlier");
|
2013-09-01 12:28:48 +08:00
|
|
|
const section_base *Base =
|
|
|
|
reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
|
2014-08-27 13:25:25 +08:00
|
|
|
return makeArrayRef(Base->segname);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2013-09-01 12:28:48 +08:00
|
|
|
MachOObjectFile::isRelocationScattered(const MachO::any_relocation_info &RE)
|
2013-04-19 02:08:55 +08:00
|
|
|
const {
|
2013-09-01 12:28:48 +08:00
|
|
|
if (getCPUType(this) == MachO::CPU_TYPE_X86_64)
|
2013-04-19 02:08:55 +08:00
|
|
|
return false;
|
2013-09-01 12:28:48 +08:00
|
|
|
return getPlainRelocationAddress(RE) & MachO::R_SCATTERED;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-07-23 06:25:07 +08:00
|
|
|
unsigned MachOObjectFile::getPlainRelocationSymbolNum(
|
2013-09-01 12:28:48 +08:00
|
|
|
const MachO::any_relocation_info &RE) const {
|
2013-04-19 02:08:55 +08:00
|
|
|
if (isLittleEndian())
|
2013-09-01 12:28:48 +08:00
|
|
|
return RE.r_word1 & 0xffffff;
|
|
|
|
return RE.r_word1 >> 8;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-07-23 06:25:07 +08:00
|
|
|
bool MachOObjectFile::getPlainRelocationExternal(
|
2013-09-01 12:28:48 +08:00
|
|
|
const MachO::any_relocation_info &RE) const {
|
2013-04-19 02:08:55 +08:00
|
|
|
if (isLittleEndian())
|
2013-09-01 12:28:48 +08:00
|
|
|
return (RE.r_word1 >> 27) & 1;
|
|
|
|
return (RE.r_word1 >> 4) & 1;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-07-23 06:25:07 +08:00
|
|
|
bool MachOObjectFile::getScatteredRelocationScattered(
|
2013-09-01 12:28:48 +08:00
|
|
|
const MachO::any_relocation_info &RE) const {
|
|
|
|
return RE.r_word0 >> 31;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-07-23 06:25:07 +08:00
|
|
|
uint32_t MachOObjectFile::getScatteredRelocationValue(
|
2013-09-01 12:28:48 +08:00
|
|
|
const MachO::any_relocation_info &RE) const {
|
|
|
|
return RE.r_word1;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2014-11-04 08:43:16 +08:00
|
|
|
uint32_t MachOObjectFile::getScatteredRelocationType(
|
|
|
|
const MachO::any_relocation_info &RE) const {
|
|
|
|
return (RE.r_word0 >> 24) & 0xf;
|
|
|
|
}
|
|
|
|
|
2013-07-23 06:25:07 +08:00
|
|
|
unsigned MachOObjectFile::getAnyRelocationAddress(
|
2013-09-01 12:28:48 +08:00
|
|
|
const MachO::any_relocation_info &RE) const {
|
2013-04-19 02:08:55 +08:00
|
|
|
if (isRelocationScattered(RE))
|
|
|
|
return getScatteredRelocationAddress(RE);
|
|
|
|
return getPlainRelocationAddress(RE);
|
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
unsigned MachOObjectFile::getAnyRelocationPCRel(
|
|
|
|
const MachO::any_relocation_info &RE) const {
|
2013-04-19 02:08:55 +08:00
|
|
|
if (isRelocationScattered(RE))
|
|
|
|
return getScatteredRelocationPCRel(this, RE);
|
|
|
|
return getPlainRelocationPCRel(this, RE);
|
|
|
|
}
|
|
|
|
|
2013-07-23 06:25:07 +08:00
|
|
|
unsigned MachOObjectFile::getAnyRelocationLength(
|
2013-09-01 12:28:48 +08:00
|
|
|
const MachO::any_relocation_info &RE) const {
|
2013-04-19 02:08:55 +08:00
|
|
|
if (isRelocationScattered(RE))
|
|
|
|
return getScatteredRelocationLength(RE);
|
|
|
|
return getPlainRelocationLength(this, RE);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned
|
2013-09-01 12:28:48 +08:00
|
|
|
MachOObjectFile::getAnyRelocationType(
|
|
|
|
const MachO::any_relocation_info &RE) const {
|
2013-04-19 02:08:55 +08:00
|
|
|
if (isRelocationScattered(RE))
|
|
|
|
return getScatteredRelocationType(RE);
|
|
|
|
return getPlainRelocationType(this, RE);
|
|
|
|
}
|
|
|
|
|
2013-04-30 23:40:54 +08:00
|
|
|
SectionRef
|
2015-05-22 05:24:32 +08:00
|
|
|
MachOObjectFile::getAnyRelocationSection(
|
2013-09-01 12:28:48 +08:00
|
|
|
const MachO::any_relocation_info &RE) const {
|
2013-04-30 23:40:54 +08:00
|
|
|
if (isRelocationScattered(RE) || getPlainRelocationExternal(RE))
|
2014-02-11 04:24:04 +08:00
|
|
|
return *section_end();
|
2015-06-19 06:38:20 +08:00
|
|
|
unsigned SecNum = getPlainRelocationSymbolNum(RE);
|
|
|
|
if (SecNum == MachO::R_ABS || SecNum > Sections.size())
|
|
|
|
return *section_end();
|
2013-04-30 23:40:54 +08:00
|
|
|
DataRefImpl DRI;
|
2015-06-19 06:38:20 +08:00
|
|
|
DRI.d.a = SecNum - 1;
|
2013-04-30 23:40:54 +08:00
|
|
|
return SectionRef(DRI, this);
|
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::section MachOObjectFile::getSection(DataRefImpl DRI) const {
|
2015-05-22 23:43:00 +08:00
|
|
|
assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
|
2013-09-01 12:28:48 +08:00
|
|
|
return getStruct<MachO::section>(this, Sections[DRI.d.a]);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::section_64 MachOObjectFile::getSection64(DataRefImpl DRI) const {
|
2015-05-22 23:43:00 +08:00
|
|
|
assert(DRI.d.a < Sections.size() && "Should have detected this earlier");
|
2013-09-01 12:28:48 +08:00
|
|
|
return getStruct<MachO::section_64>(this, Sections[DRI.d.a]);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::section MachOObjectFile::getSection(const LoadCommandInfo &L,
|
2013-04-27 04:07:33 +08:00
|
|
|
unsigned Index) const {
|
|
|
|
const char *Sec = getSectionPtr(this, L, Index);
|
2013-09-01 12:28:48 +08:00
|
|
|
return getStruct<MachO::section>(this, Sec);
|
2013-04-27 04:07:33 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::section_64 MachOObjectFile::getSection64(const LoadCommandInfo &L,
|
|
|
|
unsigned Index) const {
|
2013-04-27 04:07:33 +08:00
|
|
|
const char *Sec = getSectionPtr(this, L, Index);
|
2013-09-01 12:28:48 +08:00
|
|
|
return getStruct<MachO::section_64>(this, Sec);
|
2013-04-27 04:07:33 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::nlist
|
2013-04-19 02:08:55 +08:00
|
|
|
MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI) const {
|
2013-04-25 03:47:55 +08:00
|
|
|
const char *P = reinterpret_cast<const char *>(DRI.p);
|
2013-09-01 12:28:48 +08:00
|
|
|
return getStruct<MachO::nlist>(this, P);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::nlist_64
|
2013-04-19 02:08:55 +08:00
|
|
|
MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI) const {
|
2013-04-25 03:47:55 +08:00
|
|
|
const char *P = reinterpret_cast<const char *>(DRI.p);
|
2013-09-01 12:28:48 +08:00
|
|
|
return getStruct<MachO::nlist_64>(this, P);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::linkedit_data_command
|
|
|
|
MachOObjectFile::getLinkeditDataLoadCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::linkedit_data_command>(this, L.Ptr);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::segment_command
|
2013-04-27 04:07:33 +08:00
|
|
|
MachOObjectFile::getSegmentLoadCommand(const LoadCommandInfo &L) const {
|
2013-09-01 12:28:48 +08:00
|
|
|
return getStruct<MachO::segment_command>(this, L.Ptr);
|
2013-04-27 04:07:33 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::segment_command_64
|
2013-04-27 04:07:33 +08:00
|
|
|
MachOObjectFile::getSegment64LoadCommand(const LoadCommandInfo &L) const {
|
2013-09-01 12:28:48 +08:00
|
|
|
return getStruct<MachO::segment_command_64>(this, L.Ptr);
|
2013-04-27 04:07:33 +08:00
|
|
|
}
|
|
|
|
|
2014-12-18 08:53:40 +08:00
|
|
|
MachO::linker_option_command
|
|
|
|
MachOObjectFile::getLinkerOptionLoadCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::linker_option_command>(this, L.Ptr);
|
2013-04-27 04:07:33 +08:00
|
|
|
}
|
|
|
|
|
2014-03-19 06:09:05 +08:00
|
|
|
MachO::version_min_command
|
|
|
|
MachOObjectFile::getVersionMinLoadCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::version_min_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
2014-06-30 22:40:57 +08:00
|
|
|
MachO::dylib_command
|
|
|
|
MachOObjectFile::getDylibIDLoadCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::dylib_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
2014-09-05 00:54:47 +08:00
|
|
|
MachO::dyld_info_command
|
|
|
|
MachOObjectFile::getDyldInfoLoadCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::dyld_info_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
MachO::dylinker_command
|
|
|
|
MachOObjectFile::getDylinkerCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::dylinker_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
MachO::uuid_command
|
|
|
|
MachOObjectFile::getUuidCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::uuid_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
2014-12-04 15:37:02 +08:00
|
|
|
MachO::rpath_command
|
|
|
|
MachOObjectFile::getRpathCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::rpath_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
2014-09-05 00:54:47 +08:00
|
|
|
MachO::source_version_command
|
|
|
|
MachOObjectFile::getSourceVersionCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::source_version_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
MachO::entry_point_command
|
|
|
|
MachOObjectFile::getEntryPointCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::entry_point_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
2014-12-17 07:25:52 +08:00
|
|
|
MachO::encryption_info_command
|
|
|
|
MachOObjectFile::getEncryptionInfoCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::encryption_info_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
2014-12-17 09:01:30 +08:00
|
|
|
MachO::encryption_info_command_64
|
|
|
|
MachOObjectFile::getEncryptionInfoCommand64(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::encryption_info_command_64>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
2014-12-19 03:24:35 +08:00
|
|
|
MachO::sub_framework_command
|
|
|
|
MachOObjectFile::getSubFrameworkCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::sub_framework_command>(this, L.Ptr);
|
|
|
|
}
|
2014-06-30 22:40:57 +08:00
|
|
|
|
2014-12-19 07:13:26 +08:00
|
|
|
MachO::sub_umbrella_command
|
|
|
|
MachOObjectFile::getSubUmbrellaCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::sub_umbrella_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
2014-12-20 03:48:16 +08:00
|
|
|
MachO::sub_library_command
|
|
|
|
MachOObjectFile::getSubLibraryCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::sub_library_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
2014-12-20 05:06:24 +08:00
|
|
|
MachO::sub_client_command
|
|
|
|
MachOObjectFile::getSubClientCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::sub_client_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
2014-12-20 06:25:22 +08:00
|
|
|
MachO::routines_command
|
|
|
|
MachOObjectFile::getRoutinesCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::routines_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
MachO::routines_command_64
|
|
|
|
MachOObjectFile::getRoutinesCommand64(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::routines_command_64>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
2014-12-24 06:56:39 +08:00
|
|
|
MachO::thread_command
|
|
|
|
MachOObjectFile::getThreadCommand(const LoadCommandInfo &L) const {
|
|
|
|
return getStruct<MachO::thread_command>(this, L.Ptr);
|
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::any_relocation_info
|
2013-04-19 02:08:55 +08:00
|
|
|
MachOObjectFile::getRelocation(DataRefImpl Rel) const {
|
2014-04-04 07:51:28 +08:00
|
|
|
DataRefImpl Sec;
|
|
|
|
Sec.d.a = Rel.d.a;
|
|
|
|
uint32_t Offset;
|
|
|
|
if (is64Bit()) {
|
|
|
|
MachO::section_64 Sect = getSection64(Sec);
|
|
|
|
Offset = Sect.reloff;
|
|
|
|
} else {
|
|
|
|
MachO::section Sect = getSection(Sec);
|
|
|
|
Offset = Sect.reloff;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto P = reinterpret_cast<const MachO::any_relocation_info *>(
|
|
|
|
getPtr(this, Offset)) + Rel.d.b;
|
|
|
|
return getStruct<MachO::any_relocation_info>(
|
|
|
|
this, reinterpret_cast<const char *>(P));
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::data_in_code_entry
|
2013-06-07 01:20:50 +08:00
|
|
|
MachOObjectFile::getDice(DataRefImpl Rel) const {
|
|
|
|
const char *P = reinterpret_cast<const char *>(Rel.p);
|
2013-09-01 12:28:48 +08:00
|
|
|
return getStruct<MachO::data_in_code_entry>(this, P);
|
2013-06-07 01:20:50 +08:00
|
|
|
}
|
|
|
|
|
2015-06-05 03:22:03 +08:00
|
|
|
const MachO::mach_header &MachOObjectFile::getHeader() const {
|
2015-06-05 06:49:55 +08:00
|
|
|
return Header;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2015-06-05 03:22:03 +08:00
|
|
|
const MachO::mach_header_64 &MachOObjectFile::getHeader64() const {
|
|
|
|
assert(is64Bit());
|
|
|
|
return Header64;
|
2013-04-27 04:07:33 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
uint32_t MachOObjectFile::getIndirectSymbolTableEntry(
|
|
|
|
const MachO::dysymtab_command &DLC,
|
|
|
|
unsigned Index) const {
|
|
|
|
uint64_t Offset = DLC.indirectsymoff + Index * sizeof(uint32_t);
|
|
|
|
return getStruct<uint32_t>(this, getPtr(this, Offset));
|
2013-04-27 04:07:33 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::data_in_code_entry
|
2013-04-27 04:07:33 +08:00
|
|
|
MachOObjectFile::getDataInCodeTableEntry(uint32_t DataOffset,
|
|
|
|
unsigned Index) const {
|
2013-09-01 12:28:48 +08:00
|
|
|
uint64_t Offset = DataOffset + Index * sizeof(MachO::data_in_code_entry);
|
|
|
|
return getStruct<MachO::data_in_code_entry>(this, getPtr(this, Offset));
|
2013-04-27 04:07:33 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::symtab_command MachOObjectFile::getSymtabLoadCommand() const {
|
2014-10-24 03:37:31 +08:00
|
|
|
if (SymtabLoadCmd)
|
|
|
|
return getStruct<MachO::symtab_command>(this, SymtabLoadCmd);
|
|
|
|
|
|
|
|
// If there is no SymtabLoadCmd return a load command with zero'ed fields.
|
|
|
|
MachO::symtab_command Cmd;
|
|
|
|
Cmd.cmd = MachO::LC_SYMTAB;
|
|
|
|
Cmd.cmdsize = sizeof(MachO::symtab_command);
|
|
|
|
Cmd.symoff = 0;
|
|
|
|
Cmd.nsyms = 0;
|
|
|
|
Cmd.stroff = 0;
|
|
|
|
Cmd.strsize = 0;
|
|
|
|
return Cmd;
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::dysymtab_command MachOObjectFile::getDysymtabLoadCommand() const {
|
2014-10-24 03:37:31 +08:00
|
|
|
if (DysymtabLoadCmd)
|
|
|
|
return getStruct<MachO::dysymtab_command>(this, DysymtabLoadCmd);
|
|
|
|
|
|
|
|
// If there is no DysymtabLoadCmd return a load command with zero'ed fields.
|
|
|
|
MachO::dysymtab_command Cmd;
|
|
|
|
Cmd.cmd = MachO::LC_DYSYMTAB;
|
|
|
|
Cmd.cmdsize = sizeof(MachO::dysymtab_command);
|
|
|
|
Cmd.ilocalsym = 0;
|
|
|
|
Cmd.nlocalsym = 0;
|
|
|
|
Cmd.iextdefsym = 0;
|
|
|
|
Cmd.nextdefsym = 0;
|
|
|
|
Cmd.iundefsym = 0;
|
|
|
|
Cmd.nundefsym = 0;
|
|
|
|
Cmd.tocoff = 0;
|
|
|
|
Cmd.ntoc = 0;
|
|
|
|
Cmd.modtaboff = 0;
|
|
|
|
Cmd.nmodtab = 0;
|
|
|
|
Cmd.extrefsymoff = 0;
|
|
|
|
Cmd.nextrefsyms = 0;
|
|
|
|
Cmd.indirectsymoff = 0;
|
|
|
|
Cmd.nindirectsyms = 0;
|
|
|
|
Cmd.extreloff = 0;
|
|
|
|
Cmd.nextrel = 0;
|
|
|
|
Cmd.locreloff = 0;
|
|
|
|
Cmd.nlocrel = 0;
|
|
|
|
return Cmd;
|
2013-04-27 04:07:33 +08:00
|
|
|
}
|
|
|
|
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::linkedit_data_command
|
2013-06-07 01:20:50 +08:00
|
|
|
MachOObjectFile::getDataInCodeLoadCommand() const {
|
|
|
|
if (DataInCodeLoadCmd)
|
2013-09-01 12:28:48 +08:00
|
|
|
return getStruct<MachO::linkedit_data_command>(this, DataInCodeLoadCmd);
|
2013-06-07 01:20:50 +08:00
|
|
|
|
|
|
|
// If there is no DataInCodeLoadCmd return a load command with zero'ed fields.
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::linkedit_data_command Cmd;
|
|
|
|
Cmd.cmd = MachO::LC_DATA_IN_CODE;
|
|
|
|
Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
|
2015-01-28 05:28:24 +08:00
|
|
|
Cmd.dataoff = 0;
|
|
|
|
Cmd.datasize = 0;
|
|
|
|
return Cmd;
|
|
|
|
}
|
|
|
|
|
|
|
|
MachO::linkedit_data_command
|
|
|
|
MachOObjectFile::getLinkOptHintsLoadCommand() const {
|
|
|
|
if (LinkOptHintsLoadCmd)
|
|
|
|
return getStruct<MachO::linkedit_data_command>(this, LinkOptHintsLoadCmd);
|
|
|
|
|
|
|
|
// If there is no LinkOptHintsLoadCmd return a load command with zero'ed
|
|
|
|
// fields.
|
|
|
|
MachO::linkedit_data_command Cmd;
|
|
|
|
Cmd.cmd = MachO::LC_LINKER_OPTIMIZATION_HINT;
|
|
|
|
Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
|
2013-09-01 12:28:48 +08:00
|
|
|
Cmd.dataoff = 0;
|
|
|
|
Cmd.datasize = 0;
|
2013-06-07 01:20:50 +08:00
|
|
|
return Cmd;
|
|
|
|
}
|
|
|
|
|
2014-08-30 08:20:14 +08:00
|
|
|
ArrayRef<uint8_t> MachOObjectFile::getDyldInfoRebaseOpcodes() const {
|
2015-09-22 19:19:03 +08:00
|
|
|
if (!DyldInfoLoadCmd)
|
2015-09-21 13:32:41 +08:00
|
|
|
return None;
|
2014-08-30 08:20:14 +08:00
|
|
|
|
2015-09-22 19:13:55 +08:00
|
|
|
MachO::dyld_info_command DyldInfo =
|
|
|
|
getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
|
|
|
|
const uint8_t *Ptr =
|
|
|
|
reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.rebase_off));
|
2015-09-21 13:32:41 +08:00
|
|
|
return makeArrayRef(Ptr, DyldInfo.rebase_size);
|
2014-08-30 08:20:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ArrayRef<uint8_t> MachOObjectFile::getDyldInfoBindOpcodes() const {
|
2015-09-22 19:19:03 +08:00
|
|
|
if (!DyldInfoLoadCmd)
|
2015-09-21 13:32:41 +08:00
|
|
|
return None;
|
2014-08-30 08:20:14 +08:00
|
|
|
|
2015-09-22 19:13:55 +08:00
|
|
|
MachO::dyld_info_command DyldInfo =
|
|
|
|
getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
|
|
|
|
const uint8_t *Ptr =
|
|
|
|
reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.bind_off));
|
2015-09-21 13:32:41 +08:00
|
|
|
return makeArrayRef(Ptr, DyldInfo.bind_size);
|
2014-08-30 08:20:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ArrayRef<uint8_t> MachOObjectFile::getDyldInfoWeakBindOpcodes() const {
|
2015-09-22 19:19:03 +08:00
|
|
|
if (!DyldInfoLoadCmd)
|
2015-09-21 13:32:41 +08:00
|
|
|
return None;
|
2014-08-30 08:20:14 +08:00
|
|
|
|
2015-09-22 19:13:55 +08:00
|
|
|
MachO::dyld_info_command DyldInfo =
|
|
|
|
getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
|
|
|
|
const uint8_t *Ptr =
|
|
|
|
reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.weak_bind_off));
|
2015-09-21 13:32:41 +08:00
|
|
|
return makeArrayRef(Ptr, DyldInfo.weak_bind_size);
|
2014-08-30 08:20:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ArrayRef<uint8_t> MachOObjectFile::getDyldInfoLazyBindOpcodes() const {
|
2015-09-22 19:19:03 +08:00
|
|
|
if (!DyldInfoLoadCmd)
|
2015-09-21 13:32:41 +08:00
|
|
|
return None;
|
2014-08-30 08:20:14 +08:00
|
|
|
|
2015-09-22 19:13:55 +08:00
|
|
|
MachO::dyld_info_command DyldInfo =
|
|
|
|
getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
|
|
|
|
const uint8_t *Ptr =
|
|
|
|
reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.lazy_bind_off));
|
2015-09-21 13:32:41 +08:00
|
|
|
return makeArrayRef(Ptr, DyldInfo.lazy_bind_size);
|
2014-08-30 08:20:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ArrayRef<uint8_t> MachOObjectFile::getDyldInfoExportsTrie() const {
|
2015-09-22 19:19:03 +08:00
|
|
|
if (!DyldInfoLoadCmd)
|
2015-09-21 13:32:41 +08:00
|
|
|
return None;
|
2014-08-30 08:20:14 +08:00
|
|
|
|
2015-09-22 19:13:55 +08:00
|
|
|
MachO::dyld_info_command DyldInfo =
|
|
|
|
getStruct<MachO::dyld_info_command>(this, DyldInfoLoadCmd);
|
|
|
|
const uint8_t *Ptr =
|
|
|
|
reinterpret_cast<const uint8_t *>(getPtr(this, DyldInfo.export_off));
|
2015-09-21 13:32:41 +08:00
|
|
|
return makeArrayRef(Ptr, DyldInfo.export_size);
|
2014-08-30 08:20:14 +08:00
|
|
|
}
|
|
|
|
|
2014-10-16 07:35:45 +08:00
|
|
|
ArrayRef<uint8_t> MachOObjectFile::getUuid() const {
|
|
|
|
if (!UuidLoadCmd)
|
2015-09-21 13:32:41 +08:00
|
|
|
return None;
|
2014-10-24 23:52:05 +08:00
|
|
|
// Returning a pointer is fine as uuid doesn't need endian swapping.
|
|
|
|
const char *Ptr = UuidLoadCmd + offsetof(MachO::uuid_command, uuid);
|
2015-09-21 13:32:41 +08:00
|
|
|
return makeArrayRef(reinterpret_cast<const uint8_t *>(Ptr), 16);
|
2014-10-16 07:35:45 +08:00
|
|
|
}
|
2014-08-30 08:20:14 +08:00
|
|
|
|
2013-04-27 04:07:33 +08:00
|
|
|
StringRef MachOObjectFile::getStringTableData() const {
|
2013-09-01 12:28:48 +08:00
|
|
|
MachO::symtab_command S = getSymtabLoadCommand();
|
|
|
|
return getData().substr(S.stroff, S.strsize);
|
2013-04-27 04:07:33 +08:00
|
|
|
}
|
|
|
|
|
2013-04-19 02:08:55 +08:00
|
|
|
bool MachOObjectFile::is64Bit() const {
|
|
|
|
return getType() == getMachOType(false, true) ||
|
2014-07-16 03:35:22 +08:00
|
|
|
getType() == getMachOType(true, true);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void MachOObjectFile::ReadULEB128s(uint64_t Index,
|
|
|
|
SmallVectorImpl<uint64_t> &Out) const {
|
|
|
|
DataExtractor extractor(ObjectFile::getData(), true, 0);
|
|
|
|
|
|
|
|
uint32_t offset = Index;
|
|
|
|
uint64_t data = 0;
|
|
|
|
while (uint64_t delta = extractor.getULEB128(&offset)) {
|
|
|
|
data += delta;
|
|
|
|
Out.push_back(data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-18 03:09:37 +08:00
|
|
|
bool MachOObjectFile::isRelocatableObject() const {
|
|
|
|
return getHeader().filetype == MachO::MH_OBJECT;
|
|
|
|
}
|
|
|
|
|
2016-03-26 07:11:52 +08:00
|
|
|
Expected<std::unique_ptr<MachOObjectFile>>
|
2014-08-20 02:44:46 +08:00
|
|
|
ObjectFile::createMachOObjectFile(MemoryBufferRef Buffer) {
|
|
|
|
StringRef Magic = Buffer.getBuffer().slice(0, 4);
|
2016-03-26 05:59:14 +08:00
|
|
|
if (Magic == "\xFE\xED\xFA\xCE")
|
2016-03-26 07:11:52 +08:00
|
|
|
return MachOObjectFile::create(Buffer, false, false);
|
2016-03-29 01:45:48 +08:00
|
|
|
if (Magic == "\xCE\xFA\xED\xFE")
|
2016-03-26 07:11:52 +08:00
|
|
|
return MachOObjectFile::create(Buffer, true, false);
|
2016-03-29 01:45:48 +08:00
|
|
|
if (Magic == "\xFE\xED\xFA\xCF")
|
2016-03-26 07:11:52 +08:00
|
|
|
return MachOObjectFile::create(Buffer, false, true);
|
2016-03-29 01:45:48 +08:00
|
|
|
if (Magic == "\xCF\xFA\xED\xFE")
|
2016-03-26 07:11:52 +08:00
|
|
|
return MachOObjectFile::create(Buffer, true, true);
|
2016-05-06 07:59:57 +08:00
|
|
|
return make_error<GenericBinaryError>(Buffer.getBufferIdentifier(),
|
|
|
|
"Unrecognized MachO magic number",
|
|
|
|
object_error::invalid_file_type);
|
2013-04-19 02:08:55 +08:00
|
|
|
}
|