6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-21 18:29:45 +00:00
Code Issues Projects Releases Wiki Activity

macho-dump: Add support for dumping segment load commands.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@120203 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Daniel Dunbar 2010-11-27 08:22:29 +00:00
parent 35bf4d6d80
commit 4ba1f5e001
4 changed files with 168 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
include/llvm/Object/MachOFormat.h
View File

@ -146,6 +146,39 @@ namespace macho {
uint32_t Size;
};
/// @name Load Command Structures
/// @{
struct SegmentLoadCommand {
uint32_t Type;
uint32_t Size;
char Name[16];
uint32_t VMAddress;
uint32_t VMSize;
uint32_t FileOffset;
uint32_t FileSize;
uint32_t MaxVMProtection;
uint32_t InitialVMProtection;
uint32_t NumSections;
uint32_t Flags;
};
struct Segment64LoadCommand {
uint32_t Type;
uint32_t Size;
char Name[16];
uint64_t VMAddress;
uint64_t VMSize;
uint64_t FileOffset;
uint64_t FileSize;
uint32_t MaxVMProtection;
uint32_t InitialVMProtection;
uint32_t NumSections;
uint32_t Flags;
};
/// @}
// See <mach-o/nlist.h>.
enum SymbolTypeType {
STT_Undefined = 0x00,

9
include/llvm/Object/MachOObject.h
View File

@ -11,6 +11,7 @@
#define LLVM_OBJECT_MACHOOBJECT_H
#include <string>
#include "llvm/ADT/InMemoryStruct.h"
#include "llvm/ADT/OwningPtr.h"
#include "llvm/Object/MachOFormat.h"
@ -88,6 +89,7 @@ public:
/// @{
bool isLittleEndian() const { return IsLittleEndian; }
bool isSwappedEndian() const { return IsSwappedEndian; }
bool is64Bit() const { return Is64Bit; }
unsigned getHeaderSize() const {
@ -111,6 +113,13 @@ public:
/// \brief Retrieve the information for the given load command.
const LoadCommandInfo &getLoadCommandInfo(unsigned Index) const;
void ReadSegmentLoadCommand(
const LoadCommandInfo &LCI,
InMemoryStruct<macho::SegmentLoadCommand> &Res) const;
void ReadSegment64LoadCommand(
const LoadCommandInfo &LCI,
InMemoryStruct<macho::Segment64LoadCommand> &Res) const;
/// @}
};

68
lib/Object/MachOObject.cpp
View File

@ -16,11 +16,43 @@
using namespace llvm;
using namespace llvm::object;
/* Translation Utilities */
template<typename T>
static void SwapValue(T &Value) {
Value = sys::SwapByteOrder(Value);
}
template<typename T>
static void SwapStruct(T &Value);
template<typename T>
static void ReadInMemoryStruct(const MachOObject &MOO,
StringRef Buffer, uint64_t Base,
InMemoryStruct<T> &Res) {
typedef T struct_type;
uint64_t Size = sizeof(struct_type);
// Check that the buffer contains the expected data.
if (Base + Size > Buffer.size()) {
Res = 0;
return;
}
// Check whether we can return a direct pointer.
struct_type *Ptr = (struct_type *) (Buffer.data() + Base);
if (!MOO.isSwappedEndian()) {
Res = Ptr;
return;
}
// Otherwise, copy the struct and translate the values.
Res = *Ptr;
SwapStruct(*Res);
}
/* *** */
MachOObject::MachOObject(MemoryBuffer *Buffer_, bool IsLittleEndian_,
bool Is64Bit_)
: Buffer(Buffer_), IsLittleEndian(IsLittleEndian_), Is64Bit(Is64Bit_),
@ -120,3 +152,39 @@ MachOObject::getLoadCommandInfo(unsigned Index) const {
return LoadCommands[Index];
}
template<>
static void SwapStruct(macho::SegmentLoadCommand &Value) {
SwapValue(Value.Type);
SwapValue(Value.Size);
SwapValue(Value.VMAddress);
SwapValue(Value.VMSize);
SwapValue(Value.FileOffset);
SwapValue(Value.FileSize);
SwapValue(Value.MaxVMProtection);
SwapValue(Value.InitialVMProtection);
SwapValue(Value.NumSections);
SwapValue(Value.Flags);
}
void MachOObject::ReadSegmentLoadCommand(const LoadCommandInfo &LCI,
InMemoryStruct<macho::SegmentLoadCommand> &Res) const {
ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
}
template<>
static void SwapStruct(macho::Segment64LoadCommand &Value) {
SwapValue(Value.Type);
SwapValue(Value.Size);
SwapValue(Value.VMAddress);
SwapValue(Value.VMSize);
SwapValue(Value.FileOffset);
SwapValue(Value.FileSize);
SwapValue(Value.MaxVMProtection);
SwapValue(Value.InitialVMProtection);
SwapValue(Value.NumSections);
SwapValue(Value.Flags);
}
void MachOObject::ReadSegment64LoadCommand(const LoadCommandInfo &LCI,
InMemoryStruct<macho::Segment64LoadCommand> &Res) const {
ReadInMemoryStruct(*this, Buffer->getBuffer(), LCI.Offset, Res);
}

61
tools/macho-dump/macho-dump.cpp
View File

@ -65,20 +65,73 @@ static int DumpHeader(MachOObject &Obj) {
return 0;
}
static void DumpSegmentCommandData(StringRef Name,
uint64_t VMAddr, uint64_t VMSize,
uint64_t FileOffset, uint64_t FileSize,
uint32_t MaxProt, uint32_t InitProt,
uint32_t NumSections, uint32_t Flags) {
outs() << " ('segment_name', '";
outs().write_escaped(Name, /*UseHexEscapes=*/true) << "')\n";
outs() << " ('vm_addr', " << VMAddr << ")\n";
outs() << " ('vm_size', " << VMSize << ")\n";
outs() << " ('file_offset', " << FileOffset << ")\n";
outs() << " ('file_size', " << FileSize << ")\n";
outs() << " ('maxprot', " << MaxProt << ")\n";
outs() << " ('initprot', " << InitProt << ")\n";
outs() << " ('num_sections', " << NumSections << ")\n";
outs() << " ('flags', " << Flags << ")\n";
}
static int DumpSegmentCommand(MachOObject &Obj,
const MachOObject::LoadCommandInfo &LCI) {
InMemoryStruct<macho::SegmentLoadCommand> SLC;
Obj.ReadSegmentLoadCommand(LCI, SLC);
if (!SLC)
return Error("unable to read segment load command");
DumpSegmentCommandData(StringRef(SLC->Name, 16), SLC->VMAddress, SLC->VMSize,
SLC->FileOffset, SLC->FileSize,
SLC->MaxVMProtection, SLC->InitialVMProtection,
SLC->NumSections, SLC->Flags);
return 0;
}
static int DumpSegment64Command(MachOObject &Obj,
const MachOObject::LoadCommandInfo &LCI) {
InMemoryStruct<macho::Segment64LoadCommand> SLC;
Obj.ReadSegment64LoadCommand(LCI, SLC);
if (!SLC)
return Error("unable to read segment load command");
DumpSegmentCommandData(StringRef(SLC->Name, 16), SLC->VMAddress, SLC->VMSize,
SLC->FileOffset, SLC->FileSize,
SLC->MaxVMProtection, SLC->InitialVMProtection,
SLC->NumSections, SLC->Flags);
return 0;
}
static int DumpLoadCommand(MachOObject &Obj, unsigned Index) {
const MachOObject::LoadCommandInfo &LCI = Obj.getLoadCommandInfo(Index);
int Res = 0;
outs() << " # Load Command " << Index << "\n"
<< " (('command', " << LCI.Command.Type << ")\n"
<< " ('size', " << LCI.Command.Size << ")\n";
switch (LCI.Command.Type) {
case macho::LCT_Segment:
Res = DumpSegmentCommand(Obj, LCI);
break;
case macho::LCT_Segment64:
Res = DumpSegment64Command(Obj, LCI);
break;
default:
Warning("unknown load command: " + Twine(LCI.Command.Type));
break;
}
outs() << " ),\n";
return 0;
return Res;
}
int main(int argc, char **argv) {
@ -104,10 +157,12 @@ int main(int argc, char **argv) {
return Res;
// Print the load commands.
int Res = 0;
outs() << "('load_commands', [\n";
for (unsigned i = 0; i != InputObject->getHeader().NumLoadCommands; ++i)
DumpLoadCommand(*InputObject, i);
if ((Res = DumpLoadCommand(*InputObject, i)))
break;
outs() << "])\n";
return 0;
return Res;
}