XenOn/kolibrios-fun
1
1
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Wiki Activity
a1909c89a2
kolibrios-fun/programs/develop/objconv/macho.cpp

755 lines
33 KiB
C++
Raw Normal View History

Added objconv port. git-svn-id: svn://kolibrios.org@9683 a494cfbc-eb01-0410-851d-a64ba20cac60
2022-02-06 12:09:00 +01:00
/**************************** macho.cpp *******************************
* Author: Agner Fog
* Date created: 2007-01-06
* Last modified: 2008-06-02
* Project: objconv
* Module: macho.cpp
* Description:
* Module for reading Mach-O files
*
* Class CMACHO is used for reading, interpreting and dumping Mach-O files.
*
* Copyright 2007-2008 GNU General Public License http://www.gnu.org/licenses
*****************************************************************************/
#include "stdafx.h"
// Machine names
SIntTxt MacMachineNames[] = {
{MAC_CPU_TYPE_I386, "Intel 32 bit"},
{MAC_CPU_TYPE_X86_64, "Intel 64 bit"},
{MAC_CPU_TYPE_ARM, "Arm"},
{MAC_CPU_TYPE_SPARC, "Sparc"},
{MAC_CPU_TYPE_POWERPC, "Power PC 32 bit"},
{MAC_CPU_TYPE_POWERPC64, "Power PC 64 bit"}
};
// CPU subtype names
SIntTxt MacCPUSubtypeNames[] = {
{MAC_CPU_SUBTYPE_POWERPC_ALL, "Power PC All"},
{MAC_CPU_SUBTYPE_I386_ALL, "Intel All"}
};
// File type names
SIntTxt MacFileTypeNames[] = {
{MAC_OBJECT, "Relocatable object file"},
{MAC_EXECUTE, "demand paged executable file"},
{MAC_FVMLIB, "fixed VM shared library file"},
{MAC_CORE, "core file"},
{MAC_PRELOAD, "preloaded executable file"},
{MAC_DYLIB, "dynamicly bound shared library file"},
{MAC_DYLINKER, "dynamic link editor"},
{MAC_BUNDLE, "dynamicly bound bundle file"}
};
// Command type names
SIntTxt MacCommandTypeNames[] = {
{MAC_LC_SEGMENT, "Segment"},
{MAC_LC_SYMTAB, "Symbol table"},
{MAC_LC_SYMSEG, "gdb symbol table info (obsolete)"},
{MAC_LC_THREAD, "thread"},
{MAC_LC_UNIXTHREAD, "unix thread"},
{MAC_LC_LOADFVMLIB, "load a specified fixed VM shared library"},
{MAC_LC_IDFVMLIB, "fixed VM shared library identification"},
{MAC_LC_IDENT, "object identification info (obsolete)"},
{MAC_LC_FVMFILE, "fixed VM file inclusion (internal use)"},
{MAC_LC_PREPAGE, "prepage command (internal use)"},
{MAC_LC_DYSYMTAB, "dynamic link-edit symbol table info"},
{MAC_LC_LOAD_DYLIB, "load a dynamicly linked shared library"},
{MAC_LC_ID_DYLIB, "dynamicly linked shared lib identification"},
{MAC_LC_LOAD_DYLINKER, "load a dynamic linker"},
{MAC_LC_ID_DYLINKER, "dynamic linker identification"},
{MAC_LC_PREBOUND_DYLIB, "modules prebound for a dynamicly linked shared library"},
{MAC_LC_ROUTINES, "image routines"},
{MAC_LC_SUB_FRAMEWORK, "sub framework"},
{MAC_LC_SUB_UMBRELLA, "sub umbrella"},
{MAC_LC_SUB_CLIENT, "sub client"},
{MAC_LC_SUB_LIBRARY, "sub library"},
{MAC_LC_TWOLEVEL_HINTS, "two-level namespace lookup hints"},
{MAC_LC_PREBIND_CKSUM, "prebind checksum"},
{MAC_LC_LOAD_WEAK_DYLIB&0xFF, "load a dynamically linked shared library, all symbols weak"},
{MAC_LC_SEGMENT_64, "64-bit segment"},
{MAC_LC_ROUTINES_64, "64-bit image routine"},
{MAC_LC_UUID, "uuid"}
};
// Relocation type names, 32 bit
SIntTxt Mac32RelocationTypeNames[] = {
{MAC32_RELOC_VANILLA, "Generic"},
{MAC32_RELOC_PAIR, "Second entry of a pair"},
{MAC32_RELOC_SECTDIFF, "Section diff"},
{MAC32_RELOC_PB_LA_PTR, "Prebound lazy "},
{MAC32_RELOC_LOCAL_SECTDIFF, "SectDif local"}
};
// Relocation type names, 64 bit
SIntTxt Mac64RelocationTypeNames[] = {
{MAC64_RELOC_UNSIGNED, "absolute address"},
{MAC64_RELOC_SIGNED, "signed 32-bit displ."},
{MAC64_RELOC_BRANCH, "Rel. jump 32-bit displ."},
{MAC64_RELOC_GOT_LOAD, "MOVQ load of a GOT entry"},
{MAC64_RELOC_GOT, "other GOT reference"},
{MAC64_RELOC_SUBTRACTOR, "Subtractor"},
{MAC64_RELOC_SIGNED_1, "signed 32-bit displacement with -1 addend"},
{MAC64_RELOC_SIGNED_2, "signed 32-bit displacement with -2 addend"},
{MAC64_RELOC_SIGNED_4, "signed 32-bit displacement with -4 addend"}
};
// Symbol type names
SIntTxt MacSymbolTypeNames[] = {
{MAC_N_UNDF, "Undefined, no section"},
{MAC_N_ABS, "Absolute, no section"},
{MAC_N_SECT, "Defined"},
{MAC_N_PBUD, "Prebound undefined (defined in a dylib)"},
{MAC_N_INDR, "Indirect"}
};
// Symbol reference type names
SIntTxt MacSymbolReferenceTypeNames[] = {
{MAC_REF_FLAG_UNDEFINED_NON_LAZY, "External non lazy"},
{MAC_REF_FLAG_UNDEFINED_LAZY, "External lazy (function call)"},
{MAC_REF_FLAG_DEFINED, "Defined public"},
{MAC_REF_FLAG_PRIVATE_DEFINED, "Defined private"},
{MAC_REF_FLAG_PRIVATE_UNDEFINED_NON_LAZY, "Private undefined non lazy"},
{MAC_REF_FLAG_PRIVATE_UNDEFINED_LAZY, "Private undefined lazy"}
};
// Symbol descriptor flag names
SIntTxt MacSymbolDescriptorFlagNames[] = {
{MAC_REFERENCED_DYNAMICALLY, "Referenced dynamically"},
// {MAC_N_DESC_DISCARDED, "Discarded"},
{MAC_N_NO_DEAD_STRIP, "Don't dead-strip"},
{MAC_N_WEAK_REF, "Weak external"},
{MAC_N_WEAK_DEF, "Weak public"}
};
// Class CMACHO members:
// Constructor
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
CMACHO<MACSTRUCTURES>::CMACHO() {
// Set everything to zero
memset(this, 0, sizeof(*this));
}
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
void CMACHO<MACSTRUCTURES>::ParseFile(){
// Load and parse file buffer
FileHeader = *(TMAC_header*)Buf(); // Copy file header
// Loop through file commands
uint32 cmd, cmdsize;
uint32 currentoffset = sizeof(TMAC_header);
for (uint32 i = 1; i <= FileHeader.ncmds; i++) {
if (currentoffset >= this->GetDataSize()) {
err.submit(2016); return;
}
uint8 * currentp = (uint8*)(Buf() + currentoffset);
cmd = ((MAC_load_command*)currentp) -> cmd;
cmdsize = ((MAC_load_command*)currentp) -> cmdsize;
// Interpret specific command type
switch(cmd) {
case MAC_LC_SEGMENT: {
if (WordSize != 32) err.submit(2320); // mixed segment size
MAC_segment_command_32 * sh = (MAC_segment_command_32*)currentp;
SegmentOffset = sh->fileoff; // File offset of segment
SegmentSize = sh->filesize; // Size of segment
NumSections = sh->nsects; // Number of sections
SectionHeaderOffset = currentoffset + sizeof(TMAC_segment_command); // File offset of section headers
if (!ImageBase && strcmp(sh->segname, "__TEXT")==0) ImageBase = sh->vmaddr; // Find image base
break;}
case MAC_LC_SEGMENT_64: {
if (WordSize != 64) err.submit(2320); // mixed segment size
MAC_segment_command_64 * sh = (MAC_segment_command_64*)currentp;
SegmentOffset = (uint32)sh->fileoff; // File offset of segment
SegmentSize = (uint32)sh->filesize; // Size of segment
NumSections = sh->nsects; // Number of sections
SectionHeaderOffset = currentoffset + sizeof(TMAC_segment_command); // File offset of section headers
if (!ImageBase && strcmp(sh->segname, "__TEXT")==0) ImageBase = sh->vmaddr; // Find image base
break;}
case MAC_LC_SYMTAB: {
MAC_symtab_command * sh = (MAC_symtab_command*)currentp;
SymTabOffset = sh->symoff; // File offset of symbol table
SymTabNumber = sh->nsyms; // Number of entries in symbol table
StringTabOffset = sh->stroff; // File offset of string table
StringTabSize = sh->strsize; // Size of string table
break;}
case MAC_LC_DYSYMTAB: {
MAC_dysymtab_command * sh = (MAC_dysymtab_command*)currentp;
ilocalsym = sh->ilocalsym; // index to local symbols
nlocalsym = sh->nlocalsym; // number of local symbols
iextdefsym = sh->iextdefsym; // index to externally defined symbols
nextdefsym = sh->nextdefsym; // number of externally defined symbols
iundefsym = sh->iundefsym; // index to undefined symbols
nundefsym = sh->nundefsym; // number of undefined symbols
IndirectSymTabOffset = sh->indirectsymoff;// file offset to the indirect symbol table
IndirectSymTabNumber = sh->nindirectsyms; // number of indirect symbol table entries
break;}
}
currentoffset += cmdsize;
}
}
// Debug dump
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
void CMACHO<MACSTRUCTURES>::Dump(int options) {
uint32 icmd; // Command index
int32 isec1; // Section index within segment
int32 isec2; // Section index global
int32 nsect; // Number of sections in segment
if (options & DUMP_FILEHDR) {
// File header
printf("\nDump of Mach-O file %s", FileName);
printf("\n-----------------------------------------------");
printf("\nFile size: 0x%X", this->GetDataSize());
printf("\nFile header:");
printf("\n CPU type: %s, subtype: %s",
Lookup(MacMachineNames, FileHeader.cputype),
Lookup(MacCPUSubtypeNames, FileHeader.cpusubtype));
printf("\n File type: %s - %s",
GetFileFormatName(FileType), Lookup(MacFileTypeNames, FileHeader.filetype));
printf("\n Number of load commands: %i, Size of commands: 0x%X, Flags: %X",
FileHeader.ncmds, FileHeader.sizeofcmds, FileHeader.flags);
}
uint32 cmd; // Load command
uint32 cmdsize; // Command size
// Pointer to current position
uint8 * currentp = (uint8*)(Buf() + sizeof(TMAC_header));
// Loop through file commands
for (icmd = 1; icmd <= FileHeader.ncmds; icmd++) {
cmd = ((MAC_load_command*)currentp) -> cmd;
cmdsize = ((MAC_load_command*)currentp) -> cmdsize;
if (options & DUMP_SECTHDR) {
// Dump command header
printf("\n\nCommand %i: %s, size: 0x%X", icmd,
Lookup(MacCommandTypeNames, cmd), cmdsize);
// Interpret specific command type
switch(cmd) {
case MAC_LC_SEGMENT: {
MAC_segment_command_32 * sh = (MAC_segment_command_32*)currentp;
printf("\n Name: %s, Memory address 0x%X, Memory size 0x%X"
"\n File offset 0x%X, File size 0x%X, Maxprot 0x%X, Initprot 0x%X"
"\n Number of sections %i, Flags 0x%X",
sh->segname, sh->vmaddr, sh->vmsize,
sh->fileoff, sh->filesize, sh->maxprot, sh->initprot,
sh->nsects, sh->flags);
break;}
case MAC_LC_SEGMENT_64: {
MAC_segment_command_64 * sh = (MAC_segment_command_64*)currentp;
printf("\n Name: %s, \n Memory address 0x%08X%08X, Memory size 0x%08X%08X"
"\n File offset 0x%08X%08X, File size 0x%08X%08X\n Maxprot 0x%X, Initprot 0x%X"
"\n Number of sections %i, Flags 0x%X",
sh->segname, (uint32)(sh->vmaddr>>32), (uint32)sh->vmaddr,
(uint32)(sh->vmsize>>32), (uint32)sh->vmsize,
(uint32)(sh->fileoff>>32), (uint32)sh->fileoff,
(uint32)(sh->filesize>>32), (uint32)sh->filesize,
sh->maxprot, sh->initprot,
sh->nsects, sh->flags);
break;}
case MAC_LC_SYMTAB: {
MAC_symtab_command * sh = (MAC_symtab_command*)currentp;
printf("\n Symbol table offset 0x%X, number of symbols %i,"
"\n String table offset 0x%X, String table size 0x%X",
sh->symoff, sh->nsyms, sh->stroff, sh->strsize);
break;}
case MAC_LC_DYSYMTAB: {
MAC_dysymtab_command * sh = (MAC_dysymtab_command*)currentp;
printf("\n Index to local symbols %i, number of local symbols %i,"
"\n Index to external symbols %i, number of external symbols %i,"
"\n Index to undefined symbols %i, number of undefined symbols %i,"
"\n File offset to TOC 0x%X, number of entries in TOC %i,",
sh->ilocalsym, sh->nlocalsym, sh->iextdefsym, sh->nextdefsym,
sh->iundefsym, sh->nundefsym, sh->tocoff, sh->ntoc);
printf("\n File offset to module table 0x%X, Number of module table entries %i,"
"\n Offset to referenced symbol table 0x%X, Number of referenced symtab entries %i"
"\n Offset to indirect symbol table 0x%X, Number of indirect symtab entries %i"
"\n Offset to external relocation entries 0x%X, Number of external reloc. entries %i"
"\n Offset to local relocation entries 0x%X, Number of local reloc. entries %i",
sh->modtaboff, sh->nmodtab, sh->extrefsymoff, sh->nextrefsyms,
sh->indirectsymoff, sh->nindirectsyms, sh->extreloff, sh->nextrel,
sh->locreloff, sh->nlocrel);
break;}
}
}
currentp += cmdsize;
}
// Dump section headers
if (options & DUMP_SECTHDR) {
printf("\n\nSections:");
// Reset current pointer
currentp = (uint8*)(Buf() + sizeof(TMAC_header));
isec2 = 0;
// Loop through load commands
for (icmd = 1; icmd <= FileHeader.ncmds; icmd++) {
cmd = ((MAC_load_command*)currentp) -> cmd;
cmdsize = ((MAC_load_command*)currentp) -> cmdsize;
if (cmd == MAC_LC_SEGMENT) {
// This is a 32-bit segment command
// Number of sections in segment
nsect = ((MAC_segment_command_32*)currentp) -> nsects;
// Find first section header
MAC_section_32 * sectp = (MAC_section_32*)(currentp + sizeof(MAC_segment_command_32));
// Loop through section headers
for (isec1 = 1; isec1 <= nsect; isec1++, sectp++) {
printf("\n\nSection %i: Name: %s, Segment: %s.",
++isec2, sectp->sectname, sectp->segname);
printf("\n Memory address 0x%X, Size 0x%X, File offset 0x%X"
"\n Alignment %i, Reloc. ent. offset 0x%X, Num reloc. %i"
"\n Flags 0x%X, reserved1 0x%X, reserved2 0x%X",
sectp->addr, sectp->size, sectp->offset, 1 << sectp->align,
sectp->reloff, sectp->nreloc, sectp->flags,
sectp->reserved1, sectp->reserved2);
if (sectp->nreloc && (options & DUMP_RELTAB)) {
// Dump relocations
printf("\n Relocations:");
if (sectp->reloff >= this->GetDataSize()) {err.submit(2035); break;}
MAC_relocation_info * relp = (MAC_relocation_info*)(Buf() + sectp->reloff);
for (uint32 r = 1; r <= sectp->nreloc; r++, relp++) {
if (relp->r_address & R_SCATTERED) {
// scattered relocation into
MAC_scattered_relocation_info * scatp = (MAC_scattered_relocation_info*)relp;
if (!(scatp->r_type & MAC32_RELOC_PAIR)) {
printf ("\n Offset: 0x%X, Value: 0x%X, Length: %i, Scat. Type: %s",
scatp->r_address, scatp->r_value, 1 << scatp->r_length,
Lookup(Mac32RelocationTypeNames, scatp->r_type));
if (scatp->r_address < sectp->size) {
printf(", Inline: 0x%X", *(int32*)(Buf()+sectp->offset+scatp->r_address));
}
}
else {
// Second entry of a pair
printf ("\n Offset2: 0x%X, Value2: 0x%X, Length2: %i",
scatp->r_address, scatp->r_value, 1 << scatp->r_length);
}
if (scatp->r_pcrel) printf(", PC relative");
}
else {
// non-scattered
if (relp->r_extern) printf ("\n Symbol number %i, ", relp->r_symbolnum);
else printf ("\n Section: %i, ", relp->r_symbolnum);
printf ("Offset: 0x%X, ", relp->r_address);
if (relp->r_pcrel) printf ("PC relative, ");
printf ("\n Length: %i, Extern: %i, Type: %s",
1 << relp->r_length, relp->r_extern,
Lookup(Mac32RelocationTypeNames, relp->r_type));
if (relp->r_address < sectp->size) {
printf(", Inline: 0x%X", *(int32*)(Buf()+sectp->offset+relp->r_address));
}
}
}
}
}
}
if (cmd == MAC_LC_SEGMENT_64) {
// This is a 64-bit segment command
// Number of sections in segment
nsect = ((MAC_segment_command_64*)currentp) -> nsects;
// Find first section header
MAC_section_64 * sectp = (MAC_section_64*)(currentp + sizeof(MAC_segment_command_64));
// Loop through section headers
for (isec1 = 1; isec1 <= nsect; isec1++, sectp++) {
printf("\n\nSection %i: Name: %s, Segment: %s.",
++isec2, sectp->sectname, sectp->segname);
printf("\n Memory address 0x%X, Size 0x%X, File offset 0x%X"
"\n Alignment %i, Reloc. ent. offset 0x%X, Num reloc. %i"
"\n Flags 0x%X, reserved1 0x%X, reserved2 0x%X",
(uint32)sectp->addr, (uint32)sectp->size, sectp->offset, 1 << sectp->align,
sectp->reloff, sectp->nreloc, sectp->flags,
sectp->reserved1, sectp->reserved2);
if (sectp->nreloc && (options & DUMP_RELTAB)) {
// Dump relocations
printf("\n Relocations:");
MAC_relocation_info * relp = (MAC_relocation_info*)(Buf() + sectp->reloff);
for (uint32 r = 1; r <= sectp->nreloc; r++, relp++) {
if (relp->r_address & R_SCATTERED) {
// scattered relocation into (not used in 64-bit Mach-O)
MAC_scattered_relocation_info * scatp = (MAC_scattered_relocation_info*)relp;
if (!(scatp->r_type & MAC32_RELOC_PAIR)) {
printf ("\n Unexpected scattered relocation. Offset: 0x%X, Value: 0x%X, Length: %i, Scat. Type: %s",
scatp->r_address, scatp->r_value, 1 << scatp->r_length,
Lookup(Mac64RelocationTypeNames, scatp->r_type));
if (scatp->r_address < sectp->size) {
printf(", Inline: 0x%X", *(int32*)(Buf()+sectp->offset+scatp->r_address));
}
}
else {
// Second entry of a pair
printf ("\n Offset2: 0x%X, Value2: 0x%X, Length2: %i",
scatp->r_address, scatp->r_value, 1 << scatp->r_length);
}
if (scatp->r_pcrel) printf(", PC relative");
}
else {
// non-scattered
if (relp->r_extern) printf ("\n Symbol number %i, ", relp->r_symbolnum);
else printf ("\n Section: %i, ", relp->r_symbolnum);
printf ("Offset: 0x%X, ", relp->r_address);
if (relp->r_pcrel) printf ("PC relative, ");
printf ("\n Length: %i, Extern: %i, Type: %s",
1 << relp->r_length, relp->r_extern,
Lookup(Mac64RelocationTypeNames, relp->r_type));
if (relp->r_type != MAC64_RELOC_SUBTRACTOR && relp->r_address < sectp->size) {
// Print inline addend
if (relp->r_length == 3) {
// 8 bytes inline addend
printf(", Inline: 0x%08X%08X", *(int32*)(Buf()+sectp->offset+relp->r_address+4), *(int32*)(Buf()+sectp->offset+relp->r_address));
}
else {
// 4 bytes inline addend
printf(", Inline: 0x%08X", *(int32*)(Buf()+sectp->offset+relp->r_address));
}
}
}
}
}
}
}
currentp += cmdsize;
}
}
// pointer to string table
char * strtab = (char*)(Buf() + StringTabOffset);
// pointer to symbol table
TMAC_nlist * symp0 = (TMAC_nlist*)(Buf() + SymTabOffset);
// Dump symbol table
if (options & DUMP_SYMTAB) {
printf("\n\nSymbol table:");
uint32 i;
TMAC_nlist * symp;
// loop through symbol table
for (i = 0, symp = symp0; i < SymTabNumber; i++, symp++) {
// Header for first symbol of each category: (alphabetical within each category)
if (i == ilocalsym && nlocalsym) printf("\n\n Local symbols:");
if (i == iextdefsym && nextdefsym) printf("\n\n Public symbols:");
if (i == iundefsym && nundefsym) printf("\n\n External symbols:");
if (symp->n_strx < StringTabSize && !(symp->n_type & MAC_N_STAB)) {
printf("\n %2i %s, Section %i, Value 0x%X\n ",
i, strtab + symp->n_strx, symp->n_sect, uint32(symp->n_value));
}
else {
printf("\n String table offset: 0x%X, Section %i, Value 0x%X\n ",
symp->n_strx, symp->n_sect, uint32(symp->n_value));
}
if (symp->n_type & MAC_N_STAB) {
printf ("Debug symbol, stab = 0x%X, ", symp->n_type);
}
else {
if (symp->n_type & MAC_N_PEXT) printf ("Private external (limited global scope), ");
if (symp->n_type & MAC_N_EXT ) printf ("External, ");
printf("%s", Lookup(MacSymbolTypeNames, symp->n_type & MAC_N_TYPE));
}
printf("\n Reference type: %s, Flags: ",
Lookup(MacSymbolReferenceTypeNames, symp->n_desc & MAC_REF_TYPE));
for (uint32 f = MAC_REFERENCED_DYNAMICALLY; f <= MAC_N_WEAK_DEF; f <<= 1) {
if (symp->n_desc & f) {
printf("%s, ", Lookup(MacSymbolDescriptorFlagNames, f));
}
}
}
// Check if indirect symbol table is valid
if (IndirectSymTabNumber && IndirectSymTabOffset + IndirectSymTabNumber*4 < this->GetDataSize()) {
// Write indirect symbol table
printf("\n\n Indirect symbols:");
// loop through indirect symbol table
uint32 * IndSymip = (uint32*)(Buf() + IndirectSymTabOffset);
for (i = 0; i < IndirectSymTabNumber; i++, IndSymip++) {
// Check if index within symbol table
if (*IndSymip >= SymTabNumber) {
//err.submit(2016);
printf("\n Unknown(0x%X)", *IndSymip);
continue;
}
// Find record
TMAC_nlist * pIndSym = symp0 + *IndSymip;
// Find name
uint32 StringIndex = pIndSym->n_strx;
if (StringIndex >= StringTabSize) {
err.submit(2035); continue;
}
// print name
printf("\n %s", strtab + StringIndex);
// print type, etc.
printf(", type 0x%X, sect %i, desc 0x%X, val 0x%X",
pIndSym->n_type, pIndSym->n_sect, pIndSym->n_desc, uint32(pIndSym->n_value));
}
}
}
// Dump string table
if (options & DUMP_STRINGTB) {
printf("\n\nString table:");
uint32 str = 0, istr = 0;
while (str < StringTabSize) {
char * p = (char*)(Buf() + StringTabOffset + str);
printf("\n %3i: %s", str, p);
istr++; str += (uint32)strlen(p) + 1;
}
}
}
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
void CMACHO<MACSTRUCTURES>::PublicNames(CMemoryBuffer * Strings, CSList<SStringEntry> * Index, int m) {
// Make list of public names
uint32 i;
SStringEntry se; // Entry in Index
// Interpret header:
ParseFile();
// pointer to string table
char * strtab = (char*)(Buf() + StringTabOffset);
// loop through public symbol table
TMAC_nlist * symp = (TMAC_nlist*)(Buf() + SymTabOffset + iextdefsym * sizeof(TMAC_nlist));
for (i = 0; i < nextdefsym; i++, symp++) {
if (symp->n_strx < StringTabSize && !(symp->n_type & MAC_N_STAB)) {
// Public symbol found
se.Member = m;
// Store name
se.String = Strings->PushString(strtab + symp->n_strx);
// Store name index
Index->Push(se);
}
}
}
// Member functions for class MacSymbolTableBuilder
template <class TMAC_nlist, class MInt>
MacSymbolTableBuilder<TMAC_nlist, MInt>::MacSymbolTableBuilder() { // Constructor
sorted = 0;
}
template <class TMAC_nlist, class MInt>
void MacSymbolTableBuilder<TMAC_nlist, MInt>::AddSymbol(int OldIndex, const char * name, int type, int Desc, int section, MInt value) {
// Add symbol to list
MacSymbolRecord<TMAC_nlist> rec;
memset(&rec, 0, sizeof(rec)); // Set to zero
/* !!
if (GetNumEntries() == 0) {
// First record must indicate empty string
rec.Name = StringBuffer.PushString(""); // Empty string
Push(&rec, sizeof(rec)); // Put empty record in memory buffer
}
*/
rec.n_type = (uint8)type; // Copy values
rec.n_sect = (uint8)section;
rec.n_desc = (int16)Desc;
rec.n_value = value;
rec.Name = StringBuffer.PushString(name); // Copy name and store index
rec.OldIndex = OldIndex; // Remember old index
Push(&rec, sizeof(rec)); // Put in memory buffer
sorted = 0; // Remember not sorted
}
template <class TMAC_nlist, class MInt>
void MacSymbolTableBuilder<TMAC_nlist, MInt>::SortList() {
// Sort the list
if (sorted) return; // allready sorted
MacSymbolRecord<TMAC_nlist> * p = (MacSymbolRecord<TMAC_nlist>*)Buf(); // Point to list
// Simple Shell sort with Sedgewick gaps:
int i, j, k, gap, n = (int)GetNumEntries();
for (k = 15; k >= 0; k--) {
gap = (1 << 2 * k) | (3 << k >> 1) | 1; // Sedgewick gap grants O(N^4/3)
for (i = gap; i < n; i++) {
MacSymbolRecord<TMAC_nlist> key = p[i];
char * strkey = StringBuffer.Buf() + key.Name;
for (j = i - gap; j >= 0 && strcmp(strkey, StringBuffer.Buf() + p[j].Name) < 0; j -= gap) {
p[j + gap] = p[j];
}
p[j + gap] = key;
}
}
sorted = 1;
}
template <class TMAC_nlist, class MInt>
int MacSymbolTableBuilder<TMAC_nlist, MInt>::TranslateIndex(int OldIndex) {
// Translate old index to new index (0-based)
// Returns -1 if not found
// Don't sort list. This would change indices if __mh_executer_header added later
// if (!sorted) SortList();
MacSymbolRecord<TMAC_nlist> * p = (MacSymbolRecord<TMAC_nlist>*)Buf(); // Point to list
// Search through list for OldIndex
for (int i = 0; i < (int)GetNumEntries(); i++) {
if (p[i].OldIndex == OldIndex) {
// Match found
return i;
}
}
// Not found
return -1;
}
template <class TMAC_nlist, class MInt>
void MacSymbolTableBuilder<TMAC_nlist, MInt>::StoreList(CMemoryBuffer * SymbolTable, CMemoryBuffer * StringTable) {
// Store sorted list in buffers
// Don't sort list unless commanded to do so. Will mess up indices
// if (!sorted) SortList(); // Make sure list is sorted
MacSymbolRecord<TMAC_nlist> * p = (MacSymbolRecord<TMAC_nlist>*)Buf(); // Point to list
for (uint32 i = 0; i < GetNumEntries(); i++, p++) {
p->n_strx = StringTable->PushString(StringBuffer.Buf()+p->Name); // Put name in string table
SymbolTable->Push(p, sizeof(TMAC_nlist)); // Store only the TMAC_nlist part of the record in SymbolTable
}
}
template <class TMAC_nlist, class MInt>
int MacSymbolTableBuilder<TMAC_nlist, MInt>::Search(const char * name) {
// Search for name. Return -1 if not found.
MacSymbolRecord<TMAC_nlist> * p = (MacSymbolRecord<TMAC_nlist>*)Buf(); // Point to list
for (int i = 0; i < (int)GetNumEntries(); i++) {
if (strcmp(StringBuffer.Buf()+p[i].Name, name) == 0) {
return i; // Found
}
}
return -1; // Not found
}
template <class TMAC_nlist, class MInt>
MacSymbolRecord<TMAC_nlist> & MacSymbolTableBuilder<TMAC_nlist, MInt>::operator[] (uint32 i) {
// Access member
uint32 Offset = i * sizeof(MacSymbolRecord<TMAC_nlist>);
if (i + sizeof(MacSymbolRecord<TMAC_nlist>) > this->GetDataSize()) {
err.submit(9003); Offset = 0;
}
return Get<MacSymbolRecord<TMAC_nlist> >(Offset);
}
/****** Class CMACUNIV for parsing Macintosh universal binary *************/
CMACUNIV::CMACUNIV() {
// Default constructor
}
void CMACUNIV::Go(int options) {
// Apply command options to all components
// Check file size
if (GetDataSize() < 28) return;
// Read number of components
uint32 NumComponents = EndianChange(Get<MAC_UNIV_FAT_HEADER>(0).num_arch);
if (NumComponents == 0 || NumComponents > 10) {
// Number of components too big or too small
err.submit(2701, NumComponents);
return;
}
uint32 i; // Component number
uint32 fo; // File offset of component pointer
CConverter ComponentBuffer; // Used for converting component
CConverter OutputBuffer; // Temporary storage of output file
int DesiredWordSize = cmd.DesiredWordSize; // Desired word size, if specified on command line
// Loop through components
for (i = 0, fo = sizeof(MAC_UNIV_FAT_HEADER); i < NumComponents; i++, fo += sizeof(MAC_UNIV_FAT_ARCH)) {
// Get component pointer
MAC_UNIV_FAT_ARCH & ComponentPointer = Get<MAC_UNIV_FAT_ARCH>(fo);
// Get offset and size of component
uint32 ComponentOffset = EndianChange(ComponentPointer.offset);
uint32 ComponentSize = EndianChange(ComponentPointer.size);
// Check within range
if (ComponentOffset + ComponentSize > GetDataSize()) {
err.submit(2016);
return;
}
// Put component into buffer
ComponentBuffer.Reset();
ComponentBuffer.Push(Buf() + ComponentOffset, ComponentSize);
// Indicate component
printf("\n\n\nComponent file number %i:\n", i + 1);
// Check type
uint32 ComponentType = ComponentBuffer.GetFileType();
if (DesiredWordSize && DesiredWordSize != ComponentBuffer.WordSize) {
err.submit(1151, ComponentBuffer.WordSize);
}
else if (ComponentType != FILETYPE_MACHO_LE) {
// Format not supported
printf(" Format not supported: %s", GetFileFormatName(ComponentType));
}
else {
// Format OK. Handle component
if (cmd.DumpOptions == 0 && OutputBuffer.GetDataSize()) {
// More than one component that can be converted
err.submit(1150);
}
else {
// Transfer filenames
ComponentBuffer.FileName = FileName;
ComponentBuffer.OutputFileName = OutputFileName;
// Do command
ComponentBuffer.Go();
// Is there an output file?
if (cmd.DumpOptions == 0) {
// Save output file
ComponentBuffer >> OutputBuffer;
}
}
}
}
// Is there an output file?
if (OutputBuffer.GetDataSize()) {
// Take over output file and skip remaining components
*this << OutputBuffer;
}
}
// Make template instances for 32 and 64 bits
template class CMACHO<MAC32STRUCTURES>;
template class CMACHO<MAC64STRUCTURES>;
template class MacSymbolTableBuilder<MAC_nlist_32, int32>;
template class MacSymbolTableBuilder<MAC_nlist_64, int64>;
Copy Permalink