827 lines
35 KiB
C++
827 lines
35 KiB
C++
/**************************** cof2elf.cpp ********************************
|
|
* Author: Agner Fog
|
|
* Date created: 2006-07-20
|
|
* Last modified: 2008-05-22
|
|
* Project: objconv
|
|
* Module: cof2elf.cpp
|
|
* Description:
|
|
* Module for converting PE/COFF file to ELF file
|
|
*
|
|
* Copyright 2006-2008 GNU General Public License http://www.gnu.org/licenses
|
|
*****************************************************************************/
|
|
#include "stdafx.h"
|
|
|
|
|
|
template <class TELF_Header, class TELF_SectionHeader, class TELF_Symbol, class TELF_Relocation>
|
|
CCOF2ELF<ELFSTRUCTURES>::CCOF2ELF () {
|
|
// Constructor
|
|
memset(this, 0, sizeof(*this));
|
|
}
|
|
|
|
|
|
template <class TELF_Header, class TELF_SectionHeader, class TELF_Symbol, class TELF_Relocation>
|
|
void CCOF2ELF<ELFSTRUCTURES>::Convert() {
|
|
// Do the conversion
|
|
NumSectionsNew = 5; // Number of sections generated so far
|
|
|
|
// Allocate variable size buffers
|
|
MaxSectionsNew = NumSectionsNew + 2 * NSections; // Max number of sections needed
|
|
NewSections.SetNum(MaxSectionsNew); // Allocate buffers for each section
|
|
NewSections.SetZero(); // Initialize
|
|
NewSectionHeaders.SetNum(MaxSectionsNew); // Allocate array for temporary section headers
|
|
NewSectionHeaders.SetZero(); // Initialize
|
|
NewSectIndex.SetNum(NSections); // Array for translating old section index (0-based) to new section index
|
|
NewSectIndex.SetZero(); // Initialize
|
|
NewSymbolIndex.SetNum(NumberOfSymbols); // Array of new symbol indices
|
|
NewSymbolIndex.SetZero(); // Initialize
|
|
|
|
// Call the subfunctions
|
|
ToFile.SetFileType(FILETYPE_ELF); // Set type of to file
|
|
MakeSegments(); // Make segment headers and code/data segments
|
|
MakeSymbolTable(); // Symbol table and string tables
|
|
MakeRelocationTables(); // Relocation tables
|
|
MakeBinaryFile(); // Putting sections together
|
|
*this << ToFile; // Take over new file buffer
|
|
}
|
|
|
|
|
|
template <class TELF_Header, class TELF_SectionHeader, class TELF_Symbol, class TELF_Relocation>
|
|
void CCOF2ELF<ELFSTRUCTURES>::MakeSegments() {
|
|
// Convert subfunction: Make segment headers and code/data segments
|
|
TELF_SectionHeader NewSecHeader; // New section header
|
|
int oldsec; // Section index in old file
|
|
int newsec; // Section index in new file
|
|
uint32 SecNameIndex; // Section name index into shstrtab
|
|
char const * SecName; // Name of new section
|
|
const int WordSize = sizeof(NewFileHeader.e_entry) * 8; // word size 32 or 64 bits
|
|
|
|
// Special segment names
|
|
static const char * SpecialSegmentNames[] = {
|
|
"Null", ".symtab", ".shstrtab", ".strtab", ".stabstr"
|
|
};
|
|
// Indexes to these are:
|
|
symtab = 1; // Symbol table section number
|
|
shstrtab = 2; // Section name string table section number
|
|
strtab = 3; // Object name string table section number
|
|
stabstr = 4; // Debug string table section number
|
|
|
|
// Number of special segments = number of names in SpecialSegmentNames:
|
|
const int NumSpecialSegments = sizeof(SpecialSegmentNames)/sizeof(SpecialSegmentNames[0]);
|
|
|
|
// Make first section header string table entry empty
|
|
NewSections[shstrtab].PushString("");
|
|
|
|
// Loop through special sections, except the first Null section:
|
|
for (newsec = 0; newsec < NumSpecialSegments; newsec++) {
|
|
// Put data into new section header:
|
|
// Initialize to zero
|
|
memset(&NewSecHeader, 0, sizeof(NewSecHeader));
|
|
|
|
if (newsec > 0) {
|
|
// Put name into section header string table
|
|
SecName = SpecialSegmentNames[newsec];
|
|
SecNameIndex = NewSections[shstrtab].PushString(SecName);
|
|
|
|
// Put name into new section header
|
|
NewSecHeader.sh_name = SecNameIndex;
|
|
}
|
|
|
|
// Put section header into temporary buffer
|
|
NewSectionHeaders[newsec] = NewSecHeader;
|
|
}
|
|
|
|
// Put type, flags, etc. into special segments:
|
|
NewSectionHeaders[symtab] .sh_type = SHT_SYMTAB;
|
|
NewSectionHeaders[symtab] .sh_entsize = sizeof(TELF_Symbol);
|
|
NewSectionHeaders[symtab] .sh_link = strtab;
|
|
NewSectionHeaders[shstrtab].sh_type = SHT_STRTAB;
|
|
NewSectionHeaders[shstrtab].sh_flags = SHF_STRINGS;
|
|
NewSectionHeaders[shstrtab].sh_addralign = 1;
|
|
NewSectionHeaders[strtab] .sh_type = SHT_STRTAB;
|
|
NewSectionHeaders[strtab] .sh_flags = SHF_STRINGS;
|
|
NewSectionHeaders[strtab] .sh_addralign = 1;
|
|
NewSectionHeaders[stabstr] .sh_type = SHT_STRTAB;
|
|
NewSectionHeaders[stabstr] .sh_flags = SHF_STRINGS;
|
|
NewSectionHeaders[stabstr] .sh_addralign = 1;
|
|
|
|
if (newsec != NumSectionsNew) {
|
|
// Check my program for internal consistency
|
|
// If you get this error then change the value of NumSectionsNew in
|
|
// the constructor CCOF2ELF::CCOF2ELF to equal the number of entries in
|
|
// SpecialSegmentNames, including the Null segment
|
|
err.submit(9000);
|
|
}
|
|
|
|
// Loop through source file sections
|
|
for (oldsec = 0; oldsec < this->NSections; oldsec++) {
|
|
|
|
// Pointer to old section header
|
|
SCOFF_SectionHeader * SectionHeader = &this->SectionHeaders[oldsec];
|
|
|
|
// Get section name
|
|
SecName = this->GetSectionName(SectionHeader->Name);
|
|
if (strnicmp(SecName,"debug",5) == 0 || strnicmp(SecName+1,"debug",5) == 0) {
|
|
// This is a debug section
|
|
if (cmd.DebugInfo == CMDL_DEBUG_STRIP) {
|
|
// Remove debug info
|
|
NewSectIndex[oldsec] = COFF_SECTION_REMOVE_ME; // Remember that this section is removed
|
|
cmd.CountDebugRemoved();
|
|
continue;
|
|
}
|
|
else if (cmd.InputType != cmd.OutputType) {
|
|
err.submit(1029); // Warn that debug information is incompatible
|
|
}
|
|
}
|
|
if (strnicmp(SecName,".drectve",8) == 0 || (SectionHeader->Flags & (PE_SCN_LNK_INFO | PE_SCN_LNK_REMOVE))) {
|
|
// This is a directive section
|
|
if (cmd.ExeptionInfo) {
|
|
// Remove directive section
|
|
NewSectIndex[oldsec] = COFF_SECTION_REMOVE_ME; // Remember that this section is removed
|
|
cmd.CountExceptionRemoved();
|
|
continue;
|
|
}
|
|
}
|
|
if (strnicmp(SecName,".pdata", 6) == 0) {
|
|
// This section has exception information
|
|
if (cmd.ExeptionInfo == CMDL_EXCEPTION_STRIP) {
|
|
// Remove exception info
|
|
NewSectIndex[oldsec] = COFF_SECTION_REMOVE_ME; // Remember that this section is removed
|
|
cmd.CountExceptionRemoved();
|
|
continue;
|
|
}
|
|
else if (cmd.InputType != cmd.OutputType) {
|
|
err.submit(1030); // Warn that exception information is incompatible
|
|
}
|
|
}
|
|
|
|
if (strnicmp(SecName,".cormeta", 8) == 0) {
|
|
// This is a .NET Common Language Runtime section
|
|
err.submit(2014);
|
|
}
|
|
if (strnicmp(SecName,".rsrc", 5) == 0) {
|
|
// This section has Windows resource information
|
|
err.submit(1031);
|
|
}
|
|
|
|
// Store section index in index translation table (zero-based index)
|
|
NewSectIndex[oldsec] = newsec;
|
|
|
|
// Store section data
|
|
if (SectionHeader->SizeOfRawData > 0) {
|
|
NewSections[newsec].Push(Buf()+SectionHeader->PRawData, SectionHeader->SizeOfRawData);
|
|
}
|
|
|
|
// Put data into new section header:
|
|
// Initialize to zero
|
|
memset(&NewSecHeader, 0, sizeof(NewSecHeader));
|
|
|
|
// Section type
|
|
if (!(SectionHeader->Flags & PE_SCN_LNK_REMOVE)) {
|
|
NewSecHeader.sh_type = SHT_PROGBITS; // Program code or data
|
|
NewSecHeader.sh_flags |= SHF_ALLOC; // Occupies memory during execution
|
|
}
|
|
if (SectionHeader->Flags & PE_SCN_CNT_UNINIT_DATA) {
|
|
NewSecHeader.sh_type = SHT_NOBITS; // BSS
|
|
}
|
|
|
|
// Section flags
|
|
if (SectionHeader->Flags & PE_SCN_MEM_WRITE) {
|
|
NewSecHeader.sh_flags |= SHF_WRITE;
|
|
}
|
|
if (SectionHeader->Flags & PE_SCN_MEM_EXECUTE) {
|
|
NewSecHeader.sh_flags |= SHF_EXECINSTR;
|
|
}
|
|
|
|
// Check for special sections
|
|
if (strcmp(SecName, COFF_CONSTRUCTOR_NAME)==0) {
|
|
// Constructors segment
|
|
SecName = ELF_CONSTRUCTOR_NAME;
|
|
NewSecHeader.sh_flags = SHF_WRITE | SHF_ALLOC;
|
|
}
|
|
|
|
// Put name into section header string table
|
|
SecNameIndex = NewSections[shstrtab].PushString(SecName);
|
|
|
|
// Put name into new section header
|
|
NewSecHeader.sh_name = SecNameIndex;
|
|
|
|
// Section virtual memory address
|
|
NewSecHeader.sh_addr = SectionHeader->VirtualAddress;
|
|
|
|
// Section size in memory
|
|
NewSecHeader.sh_size = SectionHeader->VirtualSize;
|
|
|
|
// Section alignment
|
|
if (SectionHeader->Flags & PE_SCN_ALIGN_MASK) {
|
|
NewSecHeader.sh_addralign = uint32(1 << (((SectionHeader->Flags & PE_SCN_ALIGN_MASK) / PE_SCN_ALIGN_1) - 1));
|
|
}
|
|
|
|
// Put section header into temporary buffer
|
|
NewSectionHeaders[newsec] = NewSecHeader;
|
|
|
|
// Increment section number
|
|
newsec++;
|
|
|
|
if (SectionHeader->NRelocations > 0) {
|
|
// Source section has relocations.
|
|
// Make a relocation section in destination file
|
|
|
|
// Put data into relocation section header:
|
|
// Initialize to zero
|
|
memset(&NewSecHeader, 0, sizeof(NewSecHeader));
|
|
|
|
// Name for relocation section = ".rel" or ".rela" + name of section
|
|
const int MAXSECTIONNAMELENGTH = 256;
|
|
char RelocationSectionName[MAXSECTIONNAMELENGTH] = ".rel";
|
|
if (WordSize == 64) strcat(RelocationSectionName, "a"); // 32-bit: .rel, 64-bit: .rela
|
|
|
|
strncat(RelocationSectionName, SecName, MAXSECTIONNAMELENGTH-5);
|
|
RelocationSectionName[MAXSECTIONNAMELENGTH-1] = 0;
|
|
|
|
// Put name into section header string table
|
|
uint32 SecNameIndex = NewSections[shstrtab].PushString(RelocationSectionName);
|
|
|
|
// Put name into new section header
|
|
NewSecHeader.sh_name = SecNameIndex;
|
|
|
|
// Section type
|
|
NewSecHeader.sh_type = (WordSize == 32) ? SHT_REL : SHT_RELA; // Relocation section
|
|
|
|
// Put section header into temporary buffer
|
|
NewSectionHeaders[newsec] = NewSecHeader;
|
|
|
|
// Increment section number
|
|
newsec++;
|
|
}
|
|
}
|
|
// Number of sections generated
|
|
NumSectionsNew = newsec;
|
|
}
|
|
|
|
|
|
template <class TELF_Header, class TELF_SectionHeader, class TELF_Symbol, class TELF_Relocation>
|
|
void CCOF2ELF<ELFSTRUCTURES>::MakeSymbolTable() {
|
|
// Convert subfunction: Make symbol table and string tables
|
|
int isym; // current symbol table entry
|
|
int numaux; // Number of auxiliary entries in source record
|
|
int OldSectionIndex; // Index into old section table. 1-based
|
|
int NewSectionIndex; // Index into new section table. 0-based
|
|
//const int WordSize = sizeof(NewFileHeader.e_entry) * 8; // word size 32 or 64 bits
|
|
|
|
TELF_Symbol sym; // Temporary symbol table record
|
|
const char * name1; // Name of section or main record
|
|
|
|
// Pointer to old symbol table
|
|
union {
|
|
SCOFF_SymTableEntry * p; // Symtab entry pointer
|
|
int8 * b; // Used for increment
|
|
} OldSymtab;
|
|
|
|
// Make the first record empty
|
|
NewSections[symtab].Push(0, sizeof(TELF_Symbol));
|
|
|
|
// Make first string table entries empty
|
|
NewSections[strtab] .PushString("");
|
|
NewSections[stabstr].PushString("");
|
|
|
|
// Loop twice through source symbol table to get local symbols first, global symbols last
|
|
// Loop 1: Look for local symbols only
|
|
OldSymtab.p = SymbolTable; // Pointer to source symbol table
|
|
for (isym = 0; isym < this->NumberOfSymbols; isym += numaux+1, OldSymtab.b += SIZE_SCOFF_SymTableEntry*(numaux+1)) {
|
|
|
|
if (OldSymtab.b >= Buf() + DataSize) {
|
|
err.submit(2040);
|
|
break;
|
|
}
|
|
|
|
// Number of auxiliary records belonging to same symbol
|
|
numaux = OldSymtab.p->s.NumAuxSymbols; if (numaux < 0) numaux = 0;
|
|
|
|
if (OldSymtab.p->s.StorageClass != COFF_CLASS_EXTERNAL && OldSymtab.p->s.StorageClass != COFF_CLASS_WEAK_EXTERNAL) {
|
|
// Symbol is local
|
|
|
|
// Reset destination entry
|
|
memset(&sym, 0, sizeof(sym));
|
|
|
|
// Binding
|
|
sym.st_bind = STB_LOCAL;
|
|
|
|
// Get first aux record if numaux > 0
|
|
//SCOFF_SymTableEntryAux * sa = (SCOFF_SymTableEntryAux *)(OldSymtab.b + SIZE_SCOFF_SymTableEntry);
|
|
|
|
// Symbol name
|
|
name1 = this->GetSymbolName(OldSymtab.p->s.Name);
|
|
|
|
// Symbol value
|
|
sym.st_value = OldSymtab.p->s.Value;
|
|
|
|
// Get section
|
|
OldSectionIndex = OldSymtab.p->s.SectionNumber; // 1-based index into old section table
|
|
NewSectionIndex = 0; // 0-based index into old section table
|
|
if (OldSectionIndex > 0 && OldSectionIndex <= this->NSections) {
|
|
// Subtract 1 from OldSectionIndex because NewSectIndex[] is zero-based while OldSectionIndex is 1-based
|
|
// Get new section index from translation table
|
|
NewSectionIndex = NewSectIndex[OldSectionIndex-1];
|
|
}
|
|
if (NewSectionIndex == COFF_SECTION_REMOVE_ME) {
|
|
continue; // Section has been removed. Remove symbol too
|
|
}
|
|
|
|
sym.st_shndx = (uint16)NewSectionIndex;
|
|
|
|
// Check symbol type
|
|
if (OldSymtab.p->s.StorageClass == COFF_CLASS_FILE) {
|
|
// This is a filename record
|
|
if (numaux > 0 && numaux < 20) {
|
|
// Get filename from subsequent Aux records.
|
|
// Remove path from filename because the path makes no sense on a different platform.
|
|
const char * filename = GetShortFileName(OldSymtab.p);
|
|
// Put file name into string table and debug string table
|
|
sym.st_name = NewSections[strtab].PushString(filename);
|
|
NewSections[stabstr].PushString(filename);
|
|
}
|
|
// Attributes for filename record
|
|
sym.st_shndx = (uint16)SHN_ABS;
|
|
sym.st_type = STT_FILE;
|
|
sym.st_bind = STB_LOCAL;
|
|
sym.st_value = 0;
|
|
}
|
|
else if (numaux && OldSymtab.p->s.StorageClass == COFF_CLASS_STATIC
|
|
&& OldSymtab.p->s.Value == 0 && OldSymtab.p->s.Type != 0x20) {
|
|
// This is a section definition record
|
|
sym.st_name = 0; name1 = 0;
|
|
sym.st_type = STT_SECTION;
|
|
sym.st_bind = STB_LOCAL;
|
|
sym.st_value = 0;
|
|
// aux record contains length and number of relocations. Ignore aux record
|
|
}
|
|
else if (OldSymtab.p->s.SectionNumber < 0) {
|
|
// This is an absolute or debug symbol
|
|
sym.st_type = STT_NOTYPE;
|
|
sym.st_shndx = (uint16)SHN_ABS;
|
|
}
|
|
else if (OldSymtab.p->s.Type == 0 && OldSymtab.p->s.StorageClass == COFF_CLASS_FUNCTION) {
|
|
// This is a .bf, .lf, or .ef record following a function record
|
|
// Contains line number information etc. Ignore this record
|
|
continue;
|
|
}
|
|
else if (OldSymtab.p->s.SectionNumber <= 0) {
|
|
// Unknown
|
|
sym.st_type = STT_NOTYPE;
|
|
}
|
|
else {
|
|
// This is a local data definition record
|
|
sym.st_type = STT_OBJECT;
|
|
// The size is not specified in COFF record,
|
|
// so we may give it an arbitrary size:
|
|
// sym.size = 4;
|
|
}
|
|
|
|
// Put symbol name into string table if we have not already done so
|
|
if (sym.st_name == 0 && name1) {
|
|
sym.st_name = NewSections[strtab].PushString(name1);
|
|
}
|
|
|
|
// Put record into new symbol table
|
|
NewSections[symtab].Push(&sym, sizeof(sym));
|
|
|
|
// Insert into symbol translation table
|
|
NewSymbolIndex[isym] = NewSections[symtab].GetLastIndex();
|
|
|
|
} // End if not external
|
|
} // End loop 1
|
|
|
|
// Finished with local symbols
|
|
// Make index to first global symbol
|
|
NewSectionHeaders[symtab].sh_info = NewSections[symtab].GetLastIndex() + 1;
|
|
|
|
// Loop 2: Look for global symbols only
|
|
OldSymtab.p = SymbolTable; // Pointer to source symbol table
|
|
for (isym = 0; isym < NumberOfSymbols; isym += numaux+1, OldSymtab.b += SIZE_SCOFF_SymTableEntry*(numaux+1)) {
|
|
|
|
// Number of auxiliary records belonging to same symbol
|
|
numaux = OldSymtab.p->s.NumAuxSymbols; if (numaux < 0) numaux = 0;
|
|
|
|
if (OldSymtab.p->s.StorageClass == COFF_CLASS_EXTERNAL || OldSymtab.p->s.StorageClass == COFF_CLASS_WEAK_EXTERNAL) {
|
|
// Symbol is global (public or external)
|
|
|
|
// Reset destination entry
|
|
memset(&sym, 0, sizeof(sym));
|
|
|
|
// Binding
|
|
sym.st_bind = STB_GLOBAL;
|
|
if (OldSymtab.p->s.StorageClass == COFF_CLASS_WEAK_EXTERNAL) sym.st_bind = STB_WEAK;
|
|
|
|
// Get first aux record if numaux > 0
|
|
SCOFF_SymTableEntry * sa = (SCOFF_SymTableEntry*)(OldSymtab.b + SIZE_SCOFF_SymTableEntry);
|
|
|
|
// Symbol name
|
|
name1 = GetSymbolName(OldSymtab.p->s.Name);
|
|
|
|
// Symbol value
|
|
sym.st_value = OldSymtab.p->s.Value;
|
|
|
|
// Get section
|
|
OldSectionIndex = OldSymtab.p->s.SectionNumber; // 1-based index into old section table
|
|
NewSectionIndex = 0; // 0-based index into old section table
|
|
if (OldSectionIndex > 0 && OldSectionIndex <= NSections) {
|
|
// Subtract 1 from OldSectionIndex because NewSectIndex[] is zero-based while OldSectionIndex is 1-based
|
|
// Get new section index from translation table
|
|
NewSectionIndex = NewSectIndex[OldSectionIndex-1];
|
|
}
|
|
if (NewSectionIndex == COFF_SECTION_REMOVE_ME) {
|
|
continue; // Section has been removed. Remove symbol too
|
|
}
|
|
if ((int16)OldSectionIndex == COFF_SECTION_ABSOLUTE) {
|
|
NewSectionIndex = SHN_ABS;
|
|
}
|
|
|
|
sym.st_shndx = (uint16)NewSectionIndex;
|
|
|
|
// Check symbol type
|
|
if (OldSymtab.p->s.SectionNumber < 0) {
|
|
// This is an absolute or debug symbol
|
|
sym.st_type = STT_NOTYPE;
|
|
}
|
|
else if (OldSymtab.p->s.Type == COFF_TYPE_FUNCTION && OldSymtab.p->s.SectionNumber > 0) {
|
|
// This is a function definition record
|
|
sym.st_type = STT_FUNC;
|
|
if (numaux) {
|
|
// Get size from aux record
|
|
sym.st_size = sa->func.TotalSize;
|
|
}
|
|
if (sym.st_size == 0) {
|
|
// The size is not specified in the COFF file.
|
|
// We may give it an arbitrary size:
|
|
// sym.size = 1;
|
|
}
|
|
}
|
|
else if (OldSymtab.p->s.SectionNumber <= 0) {
|
|
// This is an external symbol
|
|
sym.st_type = STT_NOTYPE;
|
|
}
|
|
else {
|
|
// This is a data definition record
|
|
sym.st_type = STT_OBJECT;
|
|
// Symbol must have a size. The size is not specified in COFF record,
|
|
// so we just give it an arbitrary size
|
|
sym.st_size = 4;
|
|
}
|
|
|
|
// Put symbol name into string table if we have not already done so
|
|
if (sym.st_name == 0 && name1) {
|
|
sym.st_name = NewSections[strtab].PushString(name1);
|
|
}
|
|
|
|
// Put record into new symbol table
|
|
NewSections[symtab].Push(&sym, sizeof(sym));
|
|
|
|
// Insert into symbol translation table
|
|
NewSymbolIndex[isym] = NewSections[symtab].GetLastIndex();
|
|
|
|
} // End if external
|
|
} // End loop 2
|
|
}
|
|
|
|
|
|
template <class TELF_Header, class TELF_SectionHeader, class TELF_Symbol, class TELF_Relocation>
|
|
void CCOF2ELF<ELFSTRUCTURES>::MakeRelocationTables() {
|
|
// Convert subfunction: Relocation tables
|
|
int32 oldsec; // Relocated section number in source file
|
|
int32 newsec; // Relocated section number in destination file
|
|
int32 newsecr; // Relocation table section number in destination file
|
|
TELF_SectionHeader * NewRelTableSecHeader; // Section header for new relocation table
|
|
char TempText[32]; // Temporary text buffer
|
|
const int WordSize = sizeof(NewFileHeader.e_entry) * 8; // word size 32 or 64 bits
|
|
|
|
// Loop through source file sections
|
|
for (oldsec = 0; oldsec < NSections; oldsec++) {
|
|
|
|
// New section index
|
|
newsec = NewSectIndex[oldsec];
|
|
if (newsec == COFF_SECTION_REMOVE_ME) {
|
|
continue; // This is a debug or exception handler section which has been removed
|
|
}
|
|
|
|
// Pointer to old section header
|
|
SCOFF_SectionHeader * SectionHeader = &this->SectionHeaders[oldsec];
|
|
|
|
if (SectionHeader->NRelocations > 0) {
|
|
// This section has relocations
|
|
|
|
// Finc new relocation table section
|
|
newsecr = newsec + 1;
|
|
|
|
// Check that we have allocated a relocation section
|
|
if (oldsec+1 < this->NSections && NewSectIndex[oldsec+1] == newsecr) err.submit(9000);
|
|
if (newsecr >= NumSectionsNew) err.submit(9000);
|
|
|
|
// New relocation table section header
|
|
NewRelTableSecHeader = &NewSectionHeaders[newsecr];
|
|
|
|
// Insert header info
|
|
NewRelTableSecHeader->sh_type = (WordSize == 32) ? SHT_REL : SHT_RELA;
|
|
NewRelTableSecHeader->sh_flags = 0;
|
|
NewRelTableSecHeader->sh_addralign = WordSize / 8; // Alignment
|
|
NewRelTableSecHeader->sh_link = symtab; // Point to symbol table
|
|
NewRelTableSecHeader->sh_info = newsec; // Point to relocated section
|
|
// Entry size:
|
|
NewRelTableSecHeader->sh_entsize = (WordSize == 32) ? sizeof(Elf32_Rel) : sizeof(Elf64_Rela);
|
|
|
|
// Pointer to old relocation entry
|
|
union {
|
|
SCOFF_Relocation * p; // pointer to record
|
|
int8 * b; // used for address calculation and incrementing
|
|
} OldReloc;
|
|
|
|
// Loop through relocations
|
|
|
|
OldReloc.b = Buf() + SectionHeader->PRelocations;
|
|
for (int i = 0; i < SectionHeader->NRelocations; i++, OldReloc.b += SIZE_SCOFF_Relocation) {
|
|
|
|
// Make new relocation entry and set to zero
|
|
TELF_Relocation NewRelocEntry;
|
|
memset(&NewRelocEntry, 0, sizeof(NewRelocEntry));
|
|
|
|
// Section offset of relocated address
|
|
NewRelocEntry.r_offset = OldReloc.p->VirtualAddress;
|
|
|
|
// Target symbol
|
|
uint32 TargetSymbol = OldReloc.p->SymbolTableIndex;
|
|
if (TargetSymbol >= (uint32)NumberOfSymbols) {
|
|
err.submit(2031); // Symbol not in table
|
|
}
|
|
else { // Translate symbol number
|
|
NewRelocEntry.r_sym = NewSymbolIndex[TargetSymbol];
|
|
}
|
|
|
|
if (WordSize == 32) {
|
|
// Interpret 32-bit COFF relocation types
|
|
switch (OldReloc.p->Type) {
|
|
case COFF32_RELOC_ABS: // Ignored
|
|
NewRelocEntry.r_type = R_386_NONE; break;
|
|
|
|
case COFF32_RELOC_TOKEN: // .NET common language runtime token
|
|
err.submit(2014); // Error message
|
|
// Continue in next case and insert absolute address as token:
|
|
case COFF32_RELOC_DIR32: // 32-bit absolute virtual address
|
|
NewRelocEntry.r_type = R_386_32; break;
|
|
|
|
case COFF32_RELOC_IMGREL: // 32-bit image relative address
|
|
// Image-relative relocation not supported in ELF
|
|
if (cmd.OutputType == FILETYPE_MACHO_LE) {
|
|
// Intermediate during conversion to MachO
|
|
NewRelocEntry.r_type = R_UNSUPPORTED_IMAGEREL;
|
|
break;
|
|
}
|
|
// Work-around unsupported image-relative relocation
|
|
// Convert to absolute
|
|
NewRelocEntry.r_type = R_386_32; // Absolute relocation
|
|
if (cmd.ImageBase == 0) {
|
|
// Default image base for 32-bit Linux
|
|
cmd.ImageBase = 0x8048000; // 0x400000 ?
|
|
}
|
|
NewRelocEntry.r_addend -= cmd.ImageBase;
|
|
// Warn that image base must be set to the specified value
|
|
sprintf(TempText, "%X", cmd.ImageBase); // write value as hexadecimal
|
|
err.submit(1301, TempText); err.ClearError(1301);
|
|
break;
|
|
|
|
case COFF32_RELOC_REL32: // 32-bit self-relative
|
|
NewRelocEntry.r_type = R_386_PC32;
|
|
// Difference between EIP-relative and self-relative relocation = size of address field
|
|
NewRelocEntry.r_addend = -4; break;
|
|
/* !! error if self-relative relocation with offset
|
|
!! test data that fails = testpic32.obj */
|
|
|
|
case COFF32_RELOC_SECTION: // 16-bit section index in file
|
|
case COFF32_RELOC_SECREL: // 32-bit section-relative
|
|
case COFF32_RELOC_SECREL7: // 8-bit section-relative
|
|
// These fixup types are not supported in ELF files
|
|
if (cmd.DebugInfo != CMDL_DEBUG_STRIP) {
|
|
// Issue warning. Ignore if stripping debug info
|
|
err.submit(1010);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
err.submit(2030, OldReloc.p->Type); break; // Error: Unknown relocation type (%i) ignored
|
|
}
|
|
}
|
|
else {
|
|
// Interpret 64-bit COFF relocation types
|
|
switch (OldReloc.p->Type) {
|
|
case COFF64_RELOC_ABS: // Ignored
|
|
NewRelocEntry.r_type = R_X86_64_NONE; break;
|
|
|
|
case COFF64_RELOC_TOKEN: // .NET common language runtime token
|
|
err.submit(2014); // Error message
|
|
// Continue in next case and insert absolute address as token:
|
|
|
|
case COFF64_RELOC_ABS64: // 64 bit absolute virtual address
|
|
NewRelocEntry.r_type = R_X86_64_64; break;
|
|
|
|
case COFF64_RELOC_PPC_TOKEN:
|
|
err.submit(2014); // Error message
|
|
// Continue in next case and insert absolute address as token:
|
|
|
|
case COFF64_RELOC_ABS32: // 32 bit absolute address
|
|
NewRelocEntry.r_type = R_X86_64_32S; break;
|
|
|
|
case COFF64_RELOC_IMGREL: // 32 bit image-relative
|
|
// Image-relative relocation not supported in ELF
|
|
if (cmd.OutputType == FILETYPE_MACHO_LE) {
|
|
// Intermediate during conversion to MachO
|
|
NewRelocEntry.r_type = R_UNSUPPORTED_IMAGEREL;
|
|
break;
|
|
}
|
|
// Work-around unsupported image-relative relocation
|
|
// Convert to absolute
|
|
NewRelocEntry.r_type = R_X86_64_32S; // Absolute 32-bit relocation
|
|
if (cmd.ImageBase == 0) {
|
|
// Default image base for 64-bit Linux
|
|
cmd.ImageBase = 0x400000;
|
|
}
|
|
NewRelocEntry.r_addend -= cmd.ImageBase;
|
|
// Warn that image base must be set to the specified value
|
|
sprintf(TempText, "%X", cmd.ImageBase); // write value as hexadecimal
|
|
err.submit(1301, TempText); err.ClearError(1301);
|
|
break;
|
|
|
|
case COFF64_RELOC_REL32: // 32 bit, RIP-relative
|
|
case COFF64_RELOC_REL32_1: // 32 bit, relative to RIP - 1. For instruction with immediate byte operand
|
|
case COFF64_RELOC_REL32_2: // 32 bit, relative to RIP - 2. For instruction with immediate word operand
|
|
case COFF64_RELOC_REL32_3: // 32 bit, relative to RIP - 3. (useless)
|
|
case COFF64_RELOC_REL32_4: // 32 bit, relative to RIP - 4. For instruction with immediate dword operand
|
|
case COFF64_RELOC_REL32_5: // 32 bit, relative to RIP - 5. (useless)
|
|
NewRelocEntry.r_type = R_X86_64_PC32;
|
|
// Note:
|
|
// The microprocessor calculates RIP-relative addresses
|
|
// relative to the value of the instruction pointer AFTER
|
|
// the instruction. This is equal to the address of the
|
|
// relocated field plus the size of the relocated field
|
|
// itself plus the size of any immediate operand coming
|
|
// after the relocated field.
|
|
// The COFF format makes the correction for this offset in
|
|
// the linker by using a differet relocation type for
|
|
// immediate operand size = 0, 1, 2 or 4.
|
|
// The ELF format makes the same correction by an explicit
|
|
// addend, which is -4, -5, -6 or -8, respectively.
|
|
// The difference between RIP-relative and self-relative
|
|
// relocation is equal to the size of the address field plus
|
|
// the size of any immediate operand:
|
|
NewRelocEntry.r_addend = -(4 + OldReloc.p->Type - COFF64_RELOC_REL32);
|
|
break;
|
|
|
|
case COFF64_RELOC_SECTION: // 16-bit section index in file
|
|
case COFF64_RELOC_SECREL: // 32-bit section-relative
|
|
case COFF64_RELOC_SECREL7: // 8-bit section-relative
|
|
|
|
// These fixup types are not supported in ELF files
|
|
if (cmd.DebugInfo != CMDL_DEBUG_STRIP) {
|
|
// Issue warning. Ignore if stripping debug info
|
|
err.submit(1010);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
err.submit(2030, OldReloc.p->Type); break; // Error: Unknown relocation type (%i) ignored
|
|
}
|
|
}
|
|
|
|
// Find inline addend
|
|
int32 * paddend = 0;
|
|
if (OldReloc.p->VirtualAddress + 4 > NewSections[newsec].GetDataSize()
|
|
|| NewSectionHeaders[newsec].sh_type == SHT_NOBITS) {
|
|
// Address of relocation is invalid
|
|
err.submit(2032);
|
|
}
|
|
else {
|
|
// Make pointer to inline addend
|
|
paddend = (int32*)(NewSections[newsec].Buf()
|
|
+ NewSectionHeaders[newsec].sh_offset + OldReloc.p->VirtualAddress);
|
|
}
|
|
|
|
// Put relocation record into table
|
|
if (WordSize == 32) {
|
|
if (NewRelocEntry.r_addend != 0) {
|
|
// Use inline addends in 32 bit ELF (SHT_REL)
|
|
// Put addend inline
|
|
* paddend += uint32(NewRelocEntry.r_addend);
|
|
NewRelocEntry.r_addend = 0;
|
|
}
|
|
|
|
// Save 32-bit relocation record Elf32_Rel, not Elf32_Rela
|
|
if (NewRelocEntry.r_addend) err.submit(9000);
|
|
NewSections[newsecr].Push(&NewRelocEntry, sizeof(Elf32_Rel));
|
|
}
|
|
else {
|
|
// 64 bit
|
|
/*
|
|
if (*paddend != 0) {
|
|
// Use explicit addend in 64 bit ELF (SHT_RELA)
|
|
// Explicit addend may cause link error if it appears to point outside section
|
|
NewRelocEntry.r_addend += *paddend;
|
|
*paddend = 0;
|
|
}*/
|
|
|
|
// Save 64-bit relocation record. Must be Elf64_Rela
|
|
NewSections[newsecr].Push(&NewRelocEntry, sizeof(Elf64_Rela));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
template <class TELF_Header, class TELF_SectionHeader, class TELF_Symbol, class TELF_Relocation>
|
|
void CCOF2ELF<ELFSTRUCTURES>::MakeBinaryFile() {
|
|
// Convert subfunction: Make section headers and file header,
|
|
// and combine everything into a single memory buffer.
|
|
int32 newsec; // Section index
|
|
uint32 SecOffset; // Section offset in file
|
|
uint32 SecSize; // Section size in file
|
|
uint32 SectionHeaderOffset; // File offset to section headers
|
|
|
|
// Set file type in ToFile
|
|
ToFile.SetFileType(FILETYPE_ELF);
|
|
|
|
// Make space for file header in ToFile, but don't fill data into it yet
|
|
ToFile.Push(0, sizeof(TELF_Header));
|
|
|
|
// Loop through new section buffers
|
|
for (newsec = 0; newsec < NumSectionsNew; newsec++) {
|
|
|
|
// Size of section
|
|
SecSize = NewSections[newsec].GetDataSize();
|
|
|
|
// Put section into ToFile
|
|
SecOffset = ToFile.Push(NewSections[newsec].Buf(), SecSize);
|
|
|
|
// Put size and offset into section header
|
|
NewSectionHeaders[newsec].sh_offset = SecOffset;
|
|
NewSectionHeaders[newsec].sh_size = SecSize;
|
|
|
|
// Align before next entry
|
|
ToFile.Align(16);
|
|
}
|
|
|
|
// Start offset of section headers
|
|
SectionHeaderOffset = ToFile.GetDataSize();
|
|
|
|
// Loop through new section headers
|
|
for (newsec = 0; newsec < NumSectionsNew; newsec++) {
|
|
|
|
// Put section header into ToFile
|
|
ToFile.Push(&NewSectionHeaders[newsec], sizeof(TELF_SectionHeader));
|
|
}
|
|
|
|
// Make file header
|
|
TELF_Header FileHeader;
|
|
memset(&FileHeader, 0, sizeof(FileHeader)); // Initialize to 0
|
|
|
|
// Put file type magic number in
|
|
strcpy((char*)(FileHeader.e_ident), ELFMAG);
|
|
// File class
|
|
FileHeader.e_ident[EI_CLASS] = (WordSize == 32) ? ELFCLASS32 : ELFCLASS64;
|
|
// Data Endian-ness
|
|
FileHeader.e_ident[EI_DATA] = ELFDATA2LSB;
|
|
// ELF version
|
|
FileHeader.e_ident[EI_VERSION] = EV_CURRENT;
|
|
// ABI
|
|
FileHeader.e_ident[EI_OSABI] = ELFOSABI_SYSV;
|
|
// ABI version
|
|
FileHeader.e_ident[EI_ABIVERSION] = 0;
|
|
// File type
|
|
FileHeader.e_type = ET_REL;
|
|
// Machine architecture
|
|
FileHeader.e_machine = (WordSize == 32) ? EM_386 : EM_X86_64;
|
|
// Version
|
|
FileHeader.e_version = EV_CURRENT;
|
|
// Flags
|
|
FileHeader.e_flags = 0;
|
|
|
|
// Section header table offset
|
|
FileHeader.e_shoff = SectionHeaderOffset;
|
|
|
|
// File header size
|
|
FileHeader.e_ehsize = sizeof(TELF_Header);
|
|
|
|
// Section header size
|
|
FileHeader.e_shentsize = sizeof(TELF_SectionHeader);
|
|
|
|
// Number of section headers
|
|
FileHeader.e_shnum = (uint16)NumSectionsNew;
|
|
|
|
// Section header string table index
|
|
FileHeader.e_shstrndx = (uint16)shstrtab;
|
|
|
|
// Put file header into beginning of ToFile where we made space for it
|
|
memcpy(ToFile.Buf(), &FileHeader, sizeof(FileHeader));
|
|
}
|
|
|
|
|
|
// Make template instances for 32 and 64 bits
|
|
template class CCOF2ELF<ELF32STRUCTURES>;
|
|
template class CCOF2ELF<ELF64STRUCTURES>;
|