namespace llvm {
namespace object {
-MachOObjectFile::MachOObjectFile(MemoryBuffer *Object, MachOObject *MOO,
- error_code &ec)
- : ObjectFile(Binary::ID_MachO, Object, ec),
- MachOObj(MOO),
- RegisteredStringTable(std::numeric_limits<uint32_t>::max()) {
+MachOObjectFile::MachOObjectFile(MemoryBuffer *Object, error_code &ec)
+ : ObjectFile(Binary::ID_MachO, Object) {
+ // MachOObject takes ownership of the Buffer we passed to it, and
+ // MachOObjectFile does, too, so we need to make sure they don't get the
+ // same object. A MemoryBuffer is cheap (it's just a reference to memory,
+ // not a copy of the memory itself), so just make a new copy here for
+ // the MachOObjectFile.
+ MemoryBuffer *NewBuffer =
+ MemoryBuffer::getMemBuffer(Object->getBuffer(),
+ Object->getBufferIdentifier(), false);
+ std::string ErrorStr;
+ MachOObj.reset(MachOObject::LoadFromBuffer(NewBuffer, &ErrorStr));
+ if (!MachOObj) {
+ ec = object_error::parse_failed;
+ return;
+ }
+
DataRefImpl DRI;
moveToNextSection(DRI);
uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
}
}
+bool MachOObjectFile::is64Bit() const {
+ return MachOObj->is64Bit();
+}
+
+const MachOFormat::LoadCommand *
+MachOObjectFile::getLoadCommandInfo(unsigned Index) const {
+ uint64_t Offset;
+ uint64_t NewOffset = MachOObj->getHeaderSize();
+ const MachOFormat::LoadCommand *Load;
+ unsigned I = 0;
+ do {
+ Offset = NewOffset;
+ StringRef Data = MachOObj->getData(Offset,
+ sizeof(MachOFormat::LoadCommand));
+ Load = reinterpret_cast<const MachOFormat::LoadCommand*>(Data.data());
+ NewOffset = Offset + Load->Size;
+ ++I;
+ } while (I != Index + 1);
+
+ return Load;
+}
+
+void MachOObjectFile::ReadULEB128s(uint64_t Index,
+ SmallVectorImpl<uint64_t> &Out) const {
+ return MachOObj->ReadULEB128s(Index, Out);
+}
+
+const macho::Header &MachOObjectFile::getHeader() const {
+ return MachOObj->getHeader();
+}
ObjectFile *ObjectFile::createMachOObjectFile(MemoryBuffer *Buffer) {
error_code ec;
- std::string Err;
- MachOObject *MachOObj = MachOObject::LoadFromBuffer(Buffer, &Err);
- if (!MachOObj)
+ ObjectFile *Ret = new MachOObjectFile(Buffer, ec);
+ if (ec)
return NULL;
- // MachOObject takes ownership of the Buffer we passed to it, and
- // MachOObjectFile does, too, so we need to make sure they don't get the
- // same object. A MemoryBuffer is cheap (it's just a reference to memory,
- // not a copy of the memory itself), so just make a new copy here for
- // the MachOObjectFile.
- MemoryBuffer *NewBuffer =
- MemoryBuffer::getMemBuffer(Buffer->getBuffer(),
- Buffer->getBufferIdentifier(), false);
- return new MachOObjectFile(NewBuffer, MachOObj, ec);
+ return Ret;
}
/*===-- Symbols -----------------------------------------------------------===*/
void MachOObjectFile::moveToNextSymbol(DataRefImpl &DRI) const {
uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
while (DRI.d.a < LoadCommandCount) {
- LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
- if (LCI.Command.Type == macho::LCT_Symtab) {
- InMemoryStruct<macho::SymtabLoadCommand> SymtabLoadCmd;
- MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd);
+ const MachOFormat::LoadCommand *Command = getLoadCommandInfo(DRI.d.a);
+ if (Command->Type == macho::LCT_Symtab) {
+ const MachOFormat::SymtabLoadCommand *SymtabLoadCmd =
+ reinterpret_cast<const MachOFormat::SymtabLoadCommand*>(Command);
if (DRI.d.b < SymtabLoadCmd->NumSymbolTableEntries)
return;
}
}
}
-void MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI,
- InMemoryStruct<macho::SymbolTableEntry> &Res) const {
- InMemoryStruct<macho::SymtabLoadCommand> SymtabLoadCmd;
- LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
- MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd);
-
- if (RegisteredStringTable != DRI.d.a) {
- MachOObj->RegisterStringTable(*SymtabLoadCmd);
- RegisteredStringTable = DRI.d.a;
- }
+const MachOFormat::SymbolTableEntry *
+MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI) const {
+ const MachOFormat::LoadCommand *Command = getLoadCommandInfo(DRI.d.a);
+ const MachOFormat::SymtabLoadCommand *SymtabLoadCmd =
+ reinterpret_cast<const MachOFormat::SymtabLoadCommand*>(Command);
- MachOObj->ReadSymbolTableEntry(SymtabLoadCmd->SymbolTableOffset, DRI.d.b,
- Res);
+ return getSymbolTableEntry(DRI, SymtabLoadCmd);
}
-void MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI,
- InMemoryStruct<macho::Symbol64TableEntry> &Res) const {
- InMemoryStruct<macho::SymtabLoadCommand> SymtabLoadCmd;
- LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
- MachOObj->ReadSymtabLoadCommand(LCI, SymtabLoadCmd);
+const MachOFormat::SymbolTableEntry *
+MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI,
+ const MachOFormat::SymtabLoadCommand *SymtabLoadCmd) const {
+ uint64_t SymbolTableOffset = SymtabLoadCmd->SymbolTableOffset;
+ unsigned Index = DRI.d.b;
+ uint64_t Offset = (SymbolTableOffset +
+ Index * sizeof(macho::SymbolTableEntry));
+ StringRef Data = MachOObj->getData(Offset,
+ sizeof(MachOFormat::SymbolTableEntry));
+ return reinterpret_cast<const MachOFormat::SymbolTableEntry*>(Data.data());
+}
- if (RegisteredStringTable != DRI.d.a) {
- MachOObj->RegisterStringTable(*SymtabLoadCmd);
- RegisteredStringTable = DRI.d.a;
- }
+const MachOFormat::Symbol64TableEntry*
+MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI) const {
+ const MachOFormat::LoadCommand *Command = getLoadCommandInfo(DRI.d.a);
+ const MachOFormat::SymtabLoadCommand *SymtabLoadCmd =
+ reinterpret_cast<const MachOFormat::SymtabLoadCommand*>(Command);
- MachOObj->ReadSymbol64TableEntry(SymtabLoadCmd->SymbolTableOffset, DRI.d.b,
- Res);
+ return getSymbol64TableEntry(DRI, SymtabLoadCmd);
}
+const MachOFormat::Symbol64TableEntry*
+MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI,
+ const MachOFormat::SymtabLoadCommand *SymtabLoadCmd) const {
+ uint64_t SymbolTableOffset = SymtabLoadCmd->SymbolTableOffset;
+ unsigned Index = DRI.d.b;
+ uint64_t Offset = (SymbolTableOffset +
+ Index * sizeof(macho::Symbol64TableEntry));
+ StringRef Data = MachOObj->getData(Offset,
+ sizeof(MachOFormat::Symbol64TableEntry));
+ return reinterpret_cast<const MachOFormat::Symbol64TableEntry*>(Data.data());
+}
error_code MachOObjectFile::getSymbolNext(DataRefImpl DRI,
SymbolRef &Result) const {
error_code MachOObjectFile::getSymbolName(DataRefImpl DRI,
StringRef &Result) const {
+ const MachOFormat::LoadCommand *Command = getLoadCommandInfo(DRI.d.a);
+ const MachOFormat::SymtabLoadCommand *SymtabLoadCmd =
+ reinterpret_cast<const MachOFormat::SymtabLoadCommand*>(Command);
+
+ StringRef StringTable =
+ MachOObj->getData(SymtabLoadCmd->StringTableOffset,
+ SymtabLoadCmd->StringTableSize);
+
+ uint32_t StringIndex;
if (MachOObj->is64Bit()) {
- InMemoryStruct<macho::Symbol64TableEntry> Entry;
- getSymbol64TableEntry(DRI, Entry);
- Result = MachOObj->getStringAtIndex(Entry->StringIndex);
+ const MachOFormat::Symbol64TableEntry *Entry =
+ getSymbol64TableEntry(DRI, SymtabLoadCmd);
+ StringIndex = Entry->StringIndex;
} else {
- InMemoryStruct<macho::SymbolTableEntry> Entry;
- getSymbolTableEntry(DRI, Entry);
- Result = MachOObj->getStringAtIndex(Entry->StringIndex);
+ const MachOFormat::SymbolTableEntry *Entry =
+ getSymbolTableEntry(DRI, SymtabLoadCmd);
+ StringIndex = Entry->StringIndex;
}
+
+ const char *Start = &StringTable.data()[StringIndex];
+ Result = StringRef(Start);
+
return object_error::success;
}
error_code MachOObjectFile::getSymbolFileOffset(DataRefImpl DRI,
uint64_t &Result) const {
if (MachOObj->is64Bit()) {
- InMemoryStruct<macho::Symbol64TableEntry> Entry;
- getSymbol64TableEntry(DRI, Entry);
+ const MachOFormat::Symbol64TableEntry *Entry = getSymbol64TableEntry(DRI);
Result = Entry->Value;
if (Entry->SectionIndex) {
const MachOFormat::Section64 *Section =
Result += Section->Offset - Section->Address;
}
} else {
- InMemoryStruct<macho::SymbolTableEntry> Entry;
- getSymbolTableEntry(DRI, Entry);
+ const MachOFormat::SymbolTableEntry *Entry = getSymbolTableEntry(DRI);
Result = Entry->Value;
if (Entry->SectionIndex) {
const MachOFormat::Section *Section =
error_code MachOObjectFile::getSymbolAddress(DataRefImpl DRI,
uint64_t &Result) const {
if (MachOObj->is64Bit()) {
- InMemoryStruct<macho::Symbol64TableEntry> Entry;
- getSymbol64TableEntry(DRI, Entry);
+ const MachOFormat::Symbol64TableEntry *Entry = getSymbol64TableEntry(DRI);
Result = Entry->Value;
} else {
- InMemoryStruct<macho::SymbolTableEntry> Entry;
- getSymbolTableEntry(DRI, Entry);
+ const MachOFormat::SymbolTableEntry *Entry = getSymbolTableEntry(DRI);
Result = Entry->Value;
}
return object_error::success;
uint64_t EndOffset = 0;
uint8_t SectionIndex;
if (MachOObj->is64Bit()) {
- InMemoryStruct<macho::Symbol64TableEntry> Entry;
- getSymbol64TableEntry(DRI, Entry);
+ const MachOFormat::Symbol64TableEntry *Entry = getSymbol64TableEntry(DRI);
BeginOffset = Entry->Value;
SectionIndex = Entry->SectionIndex;
if (!SectionIndex) {
while (Command == DRI.d.a) {
moveToNextSymbol(DRI);
if (DRI.d.a < LoadCommandCount) {
- getSymbol64TableEntry(DRI, Entry);
+ Entry = getSymbol64TableEntry(DRI);
if (Entry->SectionIndex == SectionIndex && Entry->Value > BeginOffset)
if (!EndOffset || Entry->Value < EndOffset)
EndOffset = Entry->Value;
DRI.d.b++;
}
} else {
- InMemoryStruct<macho::SymbolTableEntry> Entry;
- getSymbolTableEntry(DRI, Entry);
+ const MachOFormat::SymbolTableEntry *Entry = getSymbolTableEntry(DRI);
BeginOffset = Entry->Value;
SectionIndex = Entry->SectionIndex;
if (!SectionIndex) {
while (Command == DRI.d.a) {
moveToNextSymbol(DRI);
if (DRI.d.a < LoadCommandCount) {
- getSymbolTableEntry(DRI, Entry);
+ Entry = getSymbolTableEntry(DRI);
if (Entry->SectionIndex == SectionIndex && Entry->Value > BeginOffset)
if (!EndOffset || Entry->Value < EndOffset)
EndOffset = Entry->Value;
char &Result) const {
uint8_t Type, Flags;
if (MachOObj->is64Bit()) {
- InMemoryStruct<macho::Symbol64TableEntry> Entry;
- getSymbol64TableEntry(DRI, Entry);
+ const MachOFormat::Symbol64TableEntry *Entry = getSymbol64TableEntry(DRI);
Type = Entry->Type;
Flags = Entry->Flags;
} else {
- InMemoryStruct<macho::SymbolTableEntry> Entry;
- getSymbolTableEntry(DRI, Entry);
+ const MachOFormat::SymbolTableEntry *Entry = getSymbolTableEntry(DRI);
Type = Entry->Type;
Flags = Entry->Flags;
}
uint16_t MachOFlags;
uint8_t MachOType;
if (MachOObj->is64Bit()) {
- InMemoryStruct<macho::Symbol64TableEntry> Entry;
- getSymbol64TableEntry(DRI, Entry);
+ const MachOFormat::Symbol64TableEntry *Entry = getSymbol64TableEntry(DRI);
MachOFlags = Entry->Flags;
MachOType = Entry->Type;
} else {
- InMemoryStruct<macho::SymbolTableEntry> Entry;
- getSymbolTableEntry(DRI, Entry);
+ const MachOFormat::SymbolTableEntry *Entry = getSymbolTableEntry(DRI);
MachOFlags = Entry->Flags;
MachOType = Entry->Type;
}
section_iterator &Res) const {
uint8_t index;
if (MachOObj->is64Bit()) {
- InMemoryStruct<macho::Symbol64TableEntry> Entry;
- getSymbol64TableEntry(Symb, Entry);
+ const MachOFormat::Symbol64TableEntry *Entry = getSymbol64TableEntry(Symb);
index = Entry->SectionIndex;
} else {
- InMemoryStruct<macho::SymbolTableEntry> Entry;
- getSymbolTableEntry(Symb, Entry);
+ const MachOFormat::SymbolTableEntry *Entry = getSymbolTableEntry(Symb);
index = Entry->SectionIndex;
}
SymbolRef::Type &Res) const {
uint8_t n_type;
if (MachOObj->is64Bit()) {
- InMemoryStruct<macho::Symbol64TableEntry> Entry;
- getSymbol64TableEntry(Symb, Entry);
+ const MachOFormat::Symbol64TableEntry *Entry = getSymbol64TableEntry(Symb);
n_type = Entry->Type;
} else {
- InMemoryStruct<macho::SymbolTableEntry> Entry;
- getSymbolTableEntry(Symb, Entry);
+ const MachOFormat::SymbolTableEntry *Entry = getSymbolTableEntry(Symb);
n_type = Entry->Type;
}
Res = SymbolRef::ST_Other;
void MachOObjectFile::moveToNextSection(DataRefImpl &DRI) const {
uint32_t LoadCommandCount = MachOObj->getHeader().NumLoadCommands;
while (DRI.d.a < LoadCommandCount) {
- LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
- if (LCI.Command.Type == macho::LCT_Segment) {
- InMemoryStruct<macho::SegmentLoadCommand> SegmentLoadCmd;
- MachOObj->ReadSegmentLoadCommand(LCI, SegmentLoadCmd);
+ const MachOFormat::LoadCommand *Command = getLoadCommandInfo(DRI.d.a);
+ if (Command->Type == macho::LCT_Segment) {
+ const MachOFormat::SegmentLoadCommand *SegmentLoadCmd =
+ reinterpret_cast<const MachOFormat::SegmentLoadCommand*>(Command);
if (DRI.d.b < SegmentLoadCmd->NumSections)
return;
- } else if (LCI.Command.Type == macho::LCT_Segment64) {
- InMemoryStruct<macho::Segment64LoadCommand> Segment64LoadCmd;
- MachOObj->ReadSegment64LoadCommand(LCI, Segment64LoadCmd);
+ } else if (Command->Type == macho::LCT_Segment64) {
+ const MachOFormat::Segment64LoadCommand *Segment64LoadCmd =
+ reinterpret_cast<const MachOFormat::Segment64LoadCommand*>(Command);
if (DRI.d.b < Segment64LoadCmd->NumSections)
return;
}
return object_error::success;
}
-static bool is64BitLoadCommand(const MachOObject *MachOObj, DataRefImpl DRI) {
- LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
- if (LCI.Command.Type == macho::LCT_Segment64)
+static bool is64BitLoadCommand(const MachOObjectFile *MachOObj,
+ DataRefImpl DRI) {
+ const MachOFormat::LoadCommand *Command =
+ MachOObj->getLoadCommandInfo(DRI.d.a);
+ if (Command->Type == macho::LCT_Segment64)
return true;
- assert(LCI.Command.Type == macho::LCT_Segment && "Unexpected Type.");
+ assert(Command->Type == macho::LCT_Segment && "Unexpected Type.");
return false;
}
const MachOFormat::Section *MachOObjectFile::getSection(DataRefImpl DRI) const {
- assert(!is64BitLoadCommand(MachOObj.get(), DRI));
- LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
- unsigned SectionOffset = LCI.Offset + sizeof(macho::SegmentLoadCommand) +
+ assert(!is64BitLoadCommand(this, DRI));
+ const MachOFormat::LoadCommand *Command = getLoadCommandInfo(DRI.d.a);
+ uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(Command);
+ uintptr_t SectionAddr = CommandAddr + sizeof(macho::SegmentLoadCommand) +
DRI.d.b * sizeof(MachOFormat::Section);
- StringRef Data = MachOObj->getData(SectionOffset, sizeof(MachOFormat::Section));
- return reinterpret_cast<const MachOFormat::Section*>(Data.data());
+ return reinterpret_cast<const MachOFormat::Section*>(SectionAddr);
}
std::size_t MachOObjectFile::getSectionIndex(DataRefImpl Sec) const {
const MachOFormat::Section64 *
MachOObjectFile::getSection64(DataRefImpl DRI) const {
- assert(is64BitLoadCommand(MachOObj.get(), DRI));
- LoadCommandInfo LCI = MachOObj->getLoadCommandInfo(DRI.d.a);
- unsigned SectionOffset = LCI.Offset + sizeof(macho::Segment64LoadCommand) +
+ assert(is64BitLoadCommand(this, DRI));
+ const MachOFormat::LoadCommand *Command = getLoadCommandInfo(DRI.d.a);
+ uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(Command);
+ uintptr_t SectionAddr = CommandAddr + sizeof(macho::Segment64LoadCommand) +
DRI.d.b * sizeof(MachOFormat::Section64);
- StringRef Data = MachOObj->getData(SectionOffset, sizeof(MachOFormat::Section64));
- return reinterpret_cast<const MachOFormat::Section64*>(Data.data());
+ return reinterpret_cast<const MachOFormat::Section64*>(SectionAddr);
}
static StringRef parseSegmentOrSectionName(const char *P) {
}
ArrayRef<char> MachOObjectFile::getSectionRawName(DataRefImpl DRI) const {
- if (is64BitLoadCommand(MachOObj.get(), DRI)) {
+ if (is64BitLoadCommand(this, DRI)) {
const MachOFormat::Section64 *sec = getSection64(DRI);
return ArrayRef<char>(sec->Name);
} else {
ArrayRef<char>
MachOObjectFile::getSectionRawFinalSegmentName(DataRefImpl Sec) const {
- if (is64BitLoadCommand(MachOObj.get(), Sec)) {
+ if (is64BitLoadCommand(this, Sec)) {
const MachOFormat::Section64 *sec = getSection64(Sec);
return ArrayRef<char>(sec->SegmentName, 16);
} else {
error_code MachOObjectFile::getSectionAddress(DataRefImpl DRI,
uint64_t &Result) const {
- if (is64BitLoadCommand(MachOObj.get(), DRI)) {
+ if (is64BitLoadCommand(this, DRI)) {
const MachOFormat::Section64 *Sect = getSection64(DRI);
Result = Sect->Address;
} else {
error_code MachOObjectFile::getSectionSize(DataRefImpl DRI,
uint64_t &Result) const {
- if (is64BitLoadCommand(MachOObj.get(), DRI)) {
+ if (is64BitLoadCommand(this, DRI)) {
const MachOFormat::Section64 *Sect = getSection64(DRI);
Result = Sect->Size;
} else {
error_code MachOObjectFile::getSectionContents(DataRefImpl DRI,
StringRef &Result) const {
- if (is64BitLoadCommand(MachOObj.get(), DRI)) {
+ if (is64BitLoadCommand(this, DRI)) {
const MachOFormat::Section64 *Sect = getSection64(DRI);
Result = MachOObj->getData(Sect->Offset, Sect->Size);
} else {
error_code MachOObjectFile::getSectionAlignment(DataRefImpl DRI,
uint64_t &Result) const {
- if (is64BitLoadCommand(MachOObj.get(), DRI)) {
+ if (is64BitLoadCommand(this, DRI)) {
const MachOFormat::Section64 *Sect = getSection64(DRI);
Result = uint64_t(1) << Sect->Align;
} else {
error_code MachOObjectFile::isSectionText(DataRefImpl DRI,
bool &Result) const {
- if (is64BitLoadCommand(MachOObj.get(), DRI)) {
+ if (is64BitLoadCommand(this, DRI)) {
const MachOFormat::Section64 *Sect = getSection64(DRI);
Result = Sect->Flags & macho::SF_PureInstructions;
} else {
SectEnd += SectBegin;
if (MachOObj->is64Bit()) {
- InMemoryStruct<macho::Symbol64TableEntry> Entry;
- getSymbol64TableEntry(Symb, Entry);
+ const MachOFormat::Symbol64TableEntry *Entry = getSymbol64TableEntry(Symb);
uint64_t SymAddr= Entry->Value;
Result = (SymAddr >= SectBegin) && (SymAddr < SectEnd);
} else {
- InMemoryStruct<macho::SymbolTableEntry> Entry;
- getSymbolTableEntry(Symb, Entry);
+ const MachOFormat::SymbolTableEntry *Entry = getSymbolTableEntry(Symb);
uint64_t SymAddr= Entry->Value;
Result = (SymAddr >= SectBegin) && (SymAddr < SectEnd);
}
}
relocation_iterator MachOObjectFile::getSectionRelEnd(DataRefImpl Sec) const {
uint32_t last_reloc;
- if (is64BitLoadCommand(MachOObj.get(), Sec)) {
+ if (is64BitLoadCommand(this, Sec)) {
const MachOFormat::Section64 *Sect = getSection64(Sec);
last_reloc = Sect->NumRelocationTableEntries;
} else {