/**************************** mac2mac.cpp *****************************
* Author: Agner Fog
* Date created: 2008-05-25
* Last modified: 2008-05-25
* Project: objconv
* Module: mac2mac.cpp
* Description:
* Module for changing symbol names in Mach-O file
*
* Copyright 2008 GNU General Public License http://www.gnu.org/licenses
*****************************************************************************/
#include "stdafx.h"
// All functions in this module are templated to make two versions: 32 and 64 bits.
// See instantiations at the end of this file.
// Constructor
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
CMAC2MAC<MACSTRUCTURES>::CMAC2MAC() {
// Initialize everything
memset(this, 0, sizeof(*this));
}
// Convert()
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
void CMAC2MAC<MACSTRUCTURES>::Convert() {
MakeSymbolTable(); // Remake symbol tables and string tables
MakeBinaryFile(); // Put everyting together into ToFile
ChangeSegments(); // Modify section names and relocation table symbol indices
*this << ToFile; // Take over new file buffer
}
// MakeSymbolTable()
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
void CMAC2MAC<MACSTRUCTURES>::MakeSymbolTable() {
// Remake symbol tables and string table
int OldScope = 0; // Old scope of symbol. 0=local, 1=public, 2=external
int NewScope; // New scope of symbol. 0=local, 1=public, 2=external
uint32 symi; // Old index of symbol
const char * Name1; // Old symbol name
const char * Name2; // New symbol name
int action; // Action to take on symbol
int SymType; // Symbol type
int SymDesc; // Symbol descriptor
uint8 Section; // Symbol section
// pointer to symbol table
TMAC_nlist * symp = (TMAC_nlist*)(this->Buf() + this->SymTabOffset);
// pointer to string table
char * strtab = (char*)(this->Buf() + this->StringTabOffset);
// loop through symbol table
for (symi = 0; symi < this->SymTabNumber; symi++, symp++) {
// Check indices for first symbol of each scope category
if (symi == this->iextdefsym && this->nextdefsym) OldScope = 1;
if (symi == this->iundefsym && this->nundefsym) OldScope = 2;
NewScope = OldScope;
if (symp->n_strx >= this->StringTabSize) {
// Index out of range
err.submit(2112); continue;
}
// Get symbol name
Name1 = strtab + symp->n_strx;
// Get type, descriptor and section
SymType = symp->n_type; // Symbol type
SymDesc = symp->n_desc; // Symbol descriptor
Section = symp->n_sect; // Symbol section
// Check if any change required for this symbol
action = cmd.SymbolChange(Name1, &Name2, SYMT_LOCAL + OldScope);
switch (action) {
case SYMA_NOCHANGE:
// No change
break;
case SYMA_MAKE_WEAK:
// Make symbol weak
if (cmd.OutputType == FILETYPE_COFF) {
// PE/COFF format does not support weak publics
err.submit(2200);
}
// Make weak
if (OldScope == 1) {
SymDesc |= MAC_N_WEAK_DEF; // Weak public. Allowed only in coalesced (communal) section
}
else if (OldScope == 2) {
SymDesc |= MAC_N_WEAK_REF; // Weak external
}
else {
err.submit(1020, Name1); // Local symbol
}
break;
case SYMA_MAKE_LOCAL:
// Make public symbol local, make external symbol ignored
if (OldScope == 1) {
NewScope = 0; // Public changed to local
SymType &= ~MAC_N_EXT;
}
else if (OldScope == 2) {
Section = MAC_NO_SECT; // External symbol. Set to 0
SymDesc = 0;
SymType = MAC_N_UNDF;
}
else err.submit(1021, Name1);
break;
case SYMA_CHANGE_NAME:
// Change name of symbol
Name1 = Name2; Name2 = 0;
break;
case SYMA_ALIAS:
// Make alias and keep old name
if (OldScope != 1) {
err.submit(1022, Name1); break;
}
// Make alias
NewSymbols[1].AddSymbol(-1, Name2, SymType, SymDesc, Section, symp->n_value);
break;
default:
err.submit(9000); // unknown error
}
// Store symbol, possibly modified
NewSymbols[NewScope].AddSymbol(symi, Name1, SymType, SymDesc, Section, symp->n_value);
}
// Put everything into symbol table and string table
if (this->SymTabNumber) {
NewStringTable.SetDataSize(1); // First record must indicate empty string (see nlist.n_un in Mach-O File Format Reference)
}
for (NewScope = 0; NewScope < 3; NewScope++) {
NewSymbols[NewScope].SortList(); // Sort each list alphabetically
NewSymbols[NewScope].StoreList(&NewSymbolTable, &NewStringTable);
}
// Indices to local, public and external symbols
NewIlocalsym = 0; // index to local symbols
NewNlocalsym = NewSymbols[0].GetNumEntries(); // number of local symbols
NewIextdefsym = NewNlocalsym; // index to public symbols
NewNextdefsym = NewSymbols[1].GetNumEntries();// number of public symbols
NewIundefsym = NewNlocalsym + NewNextdefsym; // index to external symbols
NewNundefsym = NewSymbols[2].GetNumEntries(); // number of external symbols
// Calculate difference in size of new tables versus old tables
// (this calculation is moved to MakeBinaryFile)
// SizeDifference = NewSymbolTable.GetDataSize + NewStringTable.GetDataSize()
// - this->SymTabNumber * sizeof(TMAC_nlist) - this->StringTabSize;
}
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
int CMAC2MAC<MACSTRUCTURES>::NewSymbolIndex(int32 OldIndex) {
// Convert subfunction: Translate old to new symbol index
int NewIndex;
int Scope;
// Search for symbol in all scopes
for (Scope = 0; Scope < 3; Scope++) {
NewIndex = NewSymbols[Scope].TranslateIndex(OldIndex);
if (NewIndex >= 0) {
// OldIndex found. Add offset into appropriate table
if (Scope == 1) NewIndex += NewIextdefsym;
else if (Scope == 2) NewIndex += NewIundefsym;
return NewIndex;
}
}
//err.submit(2031);
return -1;
}
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
uint32 CMAC2MAC<MACSTRUCTURES>::NewFileOffset(uint32 OldOffset) {
// Convert subfunction: Translate old to new file offset
if (OldOffset <= NewSymtabOffset) {
// Before symbol table. No change
return OldOffset;
}
if (OldOffset >= OldTablesEnd) {
// After string table. Add size difference
return OldOffset + SizeDifference;
}
// Between symbol table and string table.
// The possibility of something between these two tables has not been accounted for
err.submit(2052);
return 0;
}
// MakeBinaryFile()
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
void CMAC2MAC<MACSTRUCTURES>::MakeBinaryFile() {
uint32 OldSymtabEnd; // End of old symbol table
uint32 OldStringtabEnd; // End of old string table
const int WordSize = sizeof(MInt) * 8; // Word size, 32 or 64 bits
// Offset to symbol table and string table
NewSymtabOffset = this->SymTabOffset;
if (this->StringTabOffset && this->StringTabOffset < NewSymtabOffset) NewSymtabOffset = this->StringTabOffset;
if (NewSymtabOffset == 0) NewSymtabOffset = this->GetDataSize();
// Copy all headers and all data until TablesOffset
ToFile.Push(this->Buf(), NewSymtabOffset);
ToFile.Align(WordSize/8);
NewSymtabOffset = ToFile.GetDataSize();
// Copy new symbol table
ToFile.Push(NewSymbolTable.Buf(), NewSymbolTable.GetDataSize());
// Copy new string table
NewStringtabOffset = ToFile.GetDataSize();
ToFile.Push(NewStringTable.Buf(), NewStringTable.GetDataSize());
ToFile.Align(2);
NewStringtabEnd = ToFile.GetDataSize();
// Find end of old tables
OldSymtabEnd = this->SymTabOffset + this->SymTabNumber * sizeof(TMAC_nlist);
OldStringtabEnd = this->StringTabOffset + this->StringTabSize;
OldTablesEnd = OldStringtabEnd;
if (OldSymtabEnd > OldTablesEnd) OldTablesEnd = OldSymtabEnd;
if (OldTablesEnd == 0) OldTablesEnd = this->GetDataSize();
// Size difference between new and old tables
SizeDifference = NewStringtabEnd - OldTablesEnd;
// Is there anything in the old file after these tables?
if (OldTablesEnd && this->GetDataSize() > OldTablesEnd) {
// There is something after these tables. Copy it
ToFile.Push(this->Buf() + OldTablesEnd, this->GetDataSize() - OldTablesEnd);
}
}
// ChangeSegments()
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
void CMAC2MAC<MACSTRUCTURES>::ChangeSegments() {
// Convert subfunction: Change section names if needed and adjust all relocation tables
uint32 FileOffset; // Current offset into file
uint32 lcmd; // Load command
uint32 cmdsize = 0; // Command size
uint32 icmd; // Loop counter
int action; // Name change action
char * Name1; // Old name
const char * Name2; // New name
FileOffset = sizeof(TMAC_header);
// Loop through file commands
for (icmd = 1; icmd <= this->FileHeader.ncmds; icmd++, FileOffset += cmdsize) {
lcmd = ((MAC_load_command*)(ToFile.Buf() + FileOffset)) -> cmd;
cmdsize = ((MAC_load_command*)(ToFile.Buf() + FileOffset)) -> cmdsize;
// Interpret specific command type
switch(lcmd) {
case MAC_LC_SEGMENT: { // 32-bit segment
MAC_segment_command_32 * sh = (MAC_segment_command_32*)(ToFile.Buf() + FileOffset);
Name1 = sh->segname;
// Check if any change required for this symbol
action = cmd.SymbolChange(Name1, &Name2, SYMT_SECTION);
if (action == SYMA_CHANGE_NAME) {
// Change segment name
if (strlen(Name2) > 16) err.submit(1040);
strncpy(Name1, Name2, 16);
}
// Change section names and relocations in all sections under this segment
ChangeSections(FileOffset + sizeof(MAC_segment_command_32), sh->nsects);
break;}
case MAC_LC_SEGMENT_64: { // 64-bit segment
MAC_segment_command_64 * sh = (MAC_segment_command_64*)(ToFile.Buf() + FileOffset);
Name1 = sh->segname;
// Check if any change required for this symbol
action = cmd.SymbolChange(Name1, &Name2, SYMT_SECTION);
if (action == SYMA_CHANGE_NAME) {
// Change segment name
if (strlen(Name2) > 16) err.submit(1040);
strncpy(Name1, Name2, 16);
}
// Change section names and relocations in all sections under this segment
ChangeSections(FileOffset + sizeof(MAC_segment_command_64), sh->nsects);
break;}
case MAC_LC_SYMTAB: { // Symbol table header
MAC_symtab_command * sh = (MAC_symtab_command*)(ToFile.Buf() + FileOffset);
// Change table addresses
sh->symoff = NewSymtabOffset;
sh->nsyms = NewSymbolTable.GetDataSize() / sizeof(TMAC_nlist);
sh->stroff = NewStringtabOffset;
sh->strsize = NewStringtabEnd - NewStringtabOffset;
break;}
case MAC_LC_DYSYMTAB: { // dynamic link-edit symbol table
MAC_dysymtab_command * sh = (MAC_dysymtab_command*)(ToFile.Buf() + FileOffset);
// Change indices to symbol tables
sh->ilocalsym = NewIlocalsym;
sh->nlocalsym = NewNlocalsym;
sh->iextdefsym = NewIextdefsym;
sh->nextdefsym = NewNextdefsym;
sh->iundefsym = NewIundefsym;
sh->nundefsym = NewNundefsym;
// Change table addresses
sh->tocoff = NewFileOffset(sh->tocoff);
sh->modtaboff = NewFileOffset(sh->modtaboff);
sh->extrefsymoff = NewFileOffset(sh->extrefsymoff);
sh->indirectsymoff = NewFileOffset(sh->indirectsymoff);
sh->extreloff = NewFileOffset(sh->extreloff);
sh->locreloff = NewFileOffset(sh->locreloff);
if (sh->nindirectsyms) {
// Change symbol indices in import table
ChangeImportTable(sh->indirectsymoff, sh->nindirectsyms);
}
break;}
}
}
}
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
void CMAC2MAC<MACSTRUCTURES>::ChangeSections(uint32 HeaderOffset, uint32 Num) {
// Convert subfunction: Change section names and relocation records if needed
int action; // Name change action
char * Name1; // Old name
const char * Name2; // New name
uint32 isec1; // Section index
TMAC_section * secp; // Pointer to section header
uint32 irel; // Relocation index
MAC_relocation_info * relp; // Pointer to relocation record
// Loop through section headers
for (isec1 = 0; isec1 < Num; isec1++) {
// Find section header
secp = (TMAC_section*)(ToFile.Buf() + HeaderOffset + isec1*sizeof(TMAC_section));
// Segment name
Name1 = secp->segname;
action = cmd.SymbolChange(Name1, &Name2, SYMT_SECTION);
if (action == SYMA_CHANGE_NAME) {
// Change segment name
if (strlen(Name2) > 16) err.submit(1040);
strncpy(Name1, Name2, 16);
}
// Section name
Name1 = secp->sectname;
action = cmd.SymbolChange(Name1, &Name2, SYMT_SECTION);
if (action == SYMA_CHANGE_NAME) {
// Change section name
if (strlen(Name2) > 16) err.submit(1040);
strncpy(Name1, Name2, 16);
}
// Update file offset
secp->offset = NewFileOffset(secp->offset);
if (secp->nreloc) {
// This section has relocations
// Update relocations offset
secp->reloff = NewFileOffset(secp->reloff);
// Pointer to relocation records
relp = (MAC_relocation_info*)(ToFile.Buf() + secp->reloff);
// Loop through relocations, if any
for (irel = 0; irel < secp->nreloc; irel++, relp++) {
// Only non-scattered r_extern relocations have symbol index
if (!(relp->r_address & R_SCATTERED) && relp->r_extern) {
// Update symbol index
relp->r_symbolnum = NewSymbolIndex(relp->r_symbolnum);
}
}
}
}
}
template <class TMAC_header, class TMAC_segment_command, class TMAC_section, class TMAC_nlist, class MInt>
void CMAC2MAC<MACSTRUCTURES>::ChangeImportTable(uint32 FileOffset, uint32 Num) {
// Convert subfunction: Change symbol indices in import table if needed
uint32 i; // Index
uint32 * p; // pointer to current entry
// Find first entry
p = (uint32*)(ToFile.Buf() + FileOffset);
// Loop through table
for (i = 0; i < Num; i++, p++) {
// Translate symbol index
*p = NewSymbolIndex(*p);
}
}
// Make template instances for 32 and 64 bits
template class CMAC2MAC<MAC32STRUCTURES>;
template class CMAC2MAC<MAC64STRUCTURES>;