forked from KolibriOS/kolibrios
407 lines
16 KiB
C++
407 lines
16 KiB
C++
/**************************** 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>;
|