/**************************** containers.cpp **********************************
* Author: Agner Fog
* Date created: 2006-07-15
* Last modified: 2016-07-07
* Project: objconv
* Module: containers.cpp
* Description:
* Objconv is a portable C++ program for converting object file formats.
* Compile for console mode on any platform.
*
* This module contains container classes CMemoryBuffer and CFileBuffer for
* dynamic memory allocation and file read/write. See containers.h for
* further description.
*
* Copyright 2006-2016 GNU General Public License http://www.gnu.org/licenses
*****************************************************************************/
#include "stdafx.h"
// Names of file formats
SIntTxt FileFormatNames[] = {
{FILETYPE_COFF, "COFF"},
{FILETYPE_OMF, "OMF"},
{FILETYPE_ELF, "ELF"},
{FILETYPE_MACHO_LE, "Mach-O Little Endian"},
{FILETYPE_MACHO_BE, "Mach-O Big Endian"},
{FILETYPE_DOS, "DOS executable"},
{FILETYPE_WIN3X, "Windows 3.x executable"},
{FILETYPE_LIBRARY, "Function library"},
{FILETYPE_OMFLIBRARY, "Function library (OMF)"},
{IMPORT_LIBRARY_MEMBER, "Windows import library member"},
{FILETYPE_MAC_UNIVBIN, "MacIntosh universal binary"},
{FILETYPE_MS_WPO, "Whole program optimization intermediate file, Microsoft specific"},
{FILETYPE_INTEL_WPO, "Whole program optimization intermediate file, Intel specific"},
{FILETYPE_WIN_UNKNOWN, "Unknown subtype, Windows"},
{FILETYPE_ASM, "Disassembly"}
};
// Members of class CMemoryBuffer
CMemoryBuffer::CMemoryBuffer() {
// Constructor
buffer = 0;
NumEntries = DataSize = BufferSize = 0;
}
CMemoryBuffer::~CMemoryBuffer() {
// Destructor
SetSize(0); // De-allocate buffer
}
void CMemoryBuffer::SetSize(uint32 size) {
// Allocate, reallocate or deallocate buffer of specified size.
// DataSize is initially zero. It is increased by Push or PushString.
// Setting size > DataSize will allocate more buffer and fill it with zeroes but not increase DataSize.
// Setting size < DataSize will decrease DataSize so that some of the data are discarded.
// Setting size = 0 will discard all data and de-allocate the buffer.
if (size == 0) {
// Deallocate
if (buffer) delete[] buffer; // De-allocate buffer
buffer = 0;
NumEntries = DataSize = BufferSize = 0;
return;
}
if (size < DataSize) {
// Request to delete some data
DataSize = size;
return;
}
if (size <= BufferSize) {
// Request to reduce size but not delete it
return; // Ignore
}
// size = (size + 15) & uint32(-16); // Round up size to value divisible by 16
size = (size + BufferSize + 15) & uint32(-16); // Double size and round up to value divisible by 16
int8 * buffer2 = 0; // New buffer
buffer2 = new int8[size]; // Allocate new buffer
if (buffer2 == 0) {err.submit(9006); return;} // Error can't allocate
memset (buffer2, 0, size); // Initialize to all zeroes
if (buffer) {
// A smaller buffer is previously allocated
memcpy (buffer2, buffer, BufferSize); // Copy contents of old buffer into new
delete[] buffer; // De-allocate old buffer
}
buffer = buffer2; // Save pointer to buffer
BufferSize = size; // Save size
}
uint32 CMemoryBuffer::Push(void const * obj, uint32 size) {
// Add object to buffer, return offset
// Parameters:
// obj = pointer to object, 0 if fill with zeroes
// size = size of object to push
// Old offset will be offset to new object
uint32 OldOffset = DataSize;
// New data size will be old data size plus size of new object
uint32 NewOffset = DataSize + size;
if (NewOffset > BufferSize) {
// Buffer too small, allocate more space.
// We can use SetSize for this only if it is certain that obj is not
// pointing to an object previously allocated in the old buffer
// because it would be deallocated before copied into the new buffer:
// SetSize (NewOffset + NewOffset / 2 + 1024);
// Allocate more space without using SetSize:
// Double the size + 1 kB, and round up size to value divisible by 16
uint32 NewSize = (NewOffset * 2 + 1024 + 15) & uint32(-16);
int8 * buffer2 = 0; // New buffer
// Allocate new buffer
buffer2 = new int8[NewSize];
if (buffer2 == 0) {
// Error can't allocate
err.submit(9006); return 0;
}
// Initialize to all zeroes
memset (buffer2, 0, NewSize);
if (buffer) {
// A smaller buffer is previously allocated
// Copy contents of old buffer into new
memcpy (buffer2, buffer, BufferSize);
}
BufferSize = NewSize; // Save size
if (obj && size) {
// Copy object to new buffer
memcpy (buffer2 + OldOffset, obj, size);
obj = 0; // Prevent copying once more
}
// Delete old buffer after copying object
if (buffer) delete[] buffer;
// Save pointer to new buffer
buffer = buffer2;
}
// Copy object to buffer if nonzero
if (obj && size) {
memcpy (buffer + OldOffset, obj, size);
}
if (size) {
// Adjust new offset
DataSize = NewOffset;
NumEntries++;
}
// Return offset to allocated object
return OldOffset;
}
uint32 CMemoryBuffer::PushString(char const * s) {
// Add ASCIIZ string to buffer, return offset
return Push (s, uint32(strlen(s))+1);
}
uint32 CMemoryBuffer::GetLastIndex() {
// Index of last object pushed (zero-based)
return NumEntries - 1;
}
void CMemoryBuffer::SetDataSize(uint32 size) {
if (size > BufferSize) {
// Allocate more space
SetSize(size + 2048);
}
// Set DataSize to after alignment space
DataSize = size;
}
void CMemoryBuffer::Align(uint32 a) {
// Align next entry to address divisible by a
SetDataSize((DataSize + a - 1) / a * a);
}
// Members of class CFileBuffer
CFileBuffer::CFileBuffer() : CMemoryBuffer() {
// Default constructor
FileName = 0;
OutputFileName = 0;
FileType = WordSize = Executable = 0;
}
CFileBuffer::CFileBuffer(char const * filename) : CMemoryBuffer() {
// Constructor
FileName = filename;
FileType = WordSize = 0;
}
void CFileBuffer::Read(int IgnoreError) {
// Read file into buffer
uint32 status; // Error status
#ifdef _MSC_VER // Microsoft compiler prefers this:
int fh; // File handle
fh = _open(FileName, O_RDONLY | O_BINARY); // Open file in binary mode
if (fh == -1) {
// Cannot read file
if (!IgnoreError) err.submit(2103, FileName); // Error. Input file must be read
SetSize(0); return; // Make empty file buffer
}
DataSize = filelength(fh); // Get file size
if (DataSize <= 0) {
if (!IgnoreError) err.submit(2105, FileName); // Wrong size
return;}
SetSize(DataSize + 2048); // Allocate buffer, 2k extra
status = _read(fh, Buf(), DataSize); // Read from file
if (status != DataSize) err.submit(2103, FileName);
status = _close(fh); // Close file
if (status != 0) err.submit(2103, FileName);
#else // Works with most compilers:
FILE * fh = fopen(FileName, "rb");
if (!fh) {
// Cannot read file
if (!IgnoreError) err.submit(2103, FileName); // Error. Input file must be read
SetSize(0); return; // Make empty file buffer
}
// Find file size
fseek(fh, 0, SEEK_END);
long int fsize = ftell(fh);
if (fsize <= 0 || (unsigned long)fsize >= 0xFFFFFFFF) {
// File too big or zero size
err.submit(2105, FileName); fclose(fh); return;
}
DataSize = (uint32)fsize;
rewind(fh);
// Allocate buffer
SetSize(DataSize + 2048); // Allocate buffer, 2k extra
// Read entire file
status = (uint32)fread(Buf(), 1, DataSize, fh);
if (status != DataSize) err.submit(2103, FileName);
status = fclose(fh);
if (status != 0) err.submit(2103, FileName);
#endif
}
void CFileBuffer::Write() {
// Write buffer to file:
if (OutputFileName) FileName = OutputFileName;
// Two alternative ways to write a file:
#ifdef _MSC_VER // Microsoft compiler prefers this:
int fh; // File handle
uint32 status; // Error status
// Open file in binary mode
fh = _open(FileName, O_RDWR | O_BINARY | O_CREAT | O_TRUNC, _S_IREAD | _S_IWRITE);
// Check if error
if (fh == -1) {err.submit(2104, FileName); return;}
// Write file
status = _write(fh, Buf(), DataSize);
// Check if error
if (status != DataSize) err.submit(2104, FileName);
// Close file
status = _close(fh);
// Check if error
if (status != 0) err.submit(2104, FileName);
#else // Works with most compilers:
// Open file in binary mode
FILE * ff = fopen(FileName, "wb");
// Check if error
if (!ff) {err.submit(2104, FileName); return;}
// Write file
uint32 n = (uint32)fwrite(Buf(), 1, DataSize, ff);
// Check if error
if (n != DataSize) err.submit(2104, FileName);
// Close file
n = fclose(ff);
// Check if error
if (n) {err.submit(2104, FileName); return;}
#endif
}
int CFileBuffer::GetFileType() {
// Detect file type
if (FileType) return FileType; // File type already known
if (!DataSize) return 0; // No file
if (!Buf()) return 0; // No contents
uint32 namelen = FileName ? (uint32)strlen(FileName) : 0;
if (strncmp(Buf(),"!<arch>",7) == 0) {
// UNIX style library. Contains members of file type COFF, ELF or MACHO
FileType = FILETYPE_LIBRARY;
}
else if (strncmp(Buf(),ELFMAG,4) == 0) {
// ELF file
FileType = FILETYPE_ELF;
Executable = Get<Elf32_Ehdr>(0).e_type != ET_REL;
switch (Buf()[EI_CLASS]) {
case ELFCLASS32:
WordSize = 32; break;
case ELFCLASS64:
WordSize = 64; break;
}
}
else if (Get<uint32>(0) == MAC_MAGIC_32) {
// Mach-O 32 little endian
FileType = FILETYPE_MACHO_LE;
WordSize = 32;
Executable = Get<MAC_header_32>(0).filetype != MAC_OBJECT;
}
else if (Get<uint32>(0) == MAC_MAGIC_64) {
// Mach-O 64 little endian
FileType = FILETYPE_MACHO_LE;
WordSize = 64;
Executable = Get<MAC_header_64>(0).filetype != MAC_OBJECT;
}
else if (Get<uint32>(0) == MAC_CIGAM_32) {
// Mach-O 32 big endian
FileType = FILETYPE_MACHO_BE;
WordSize = 32;
}
else if (Get<uint32>(0) == MAC_CIGAM_64) {
// Mach-O 64 big endian
FileType = FILETYPE_MACHO_BE;
WordSize = 64;
}
else if (Get<uint32>(0) == MAC_CIGAM_UNIV) {
// MacIntosh universal binary
FileType = FILETYPE_MAC_UNIVBIN;
WordSize = 0;
}
else if (Get<uint32>(0) == 0xFFFF0000 || Get<uint32>(0) == 0x10000) {
// Windows subtypes:
if (Get<uint16>(4) == 0) {
// This type only occurs when attempting to extract a member from an import library
FileType = IMPORT_LIBRARY_MEMBER;
}
else if (Get<uint16>(4) == 1) {
// Whole program optimization intermediate file for MS compiler. Undocumented
FileType = FILETYPE_MS_WPO;
}
else {
// Other subtypes not known
FileType = FILETYPE_WIN_UNKNOWN;
}
// Get word size
if (Get<uint16>(6) == PE_MACHINE_I386) {
WordSize = 32;
}
else if (Get<uint16>(6) == PE_MACHINE_X8664) {
WordSize = 64;
}
else {
WordSize = 0;
}
}
else if (Get<uint16>(0) == PE_MACHINE_I386) {
// COFF/PE 32
FileType = FILETYPE_COFF;
WordSize = 32;
Executable = (Get<SCOFF_FileHeader>(0).Flags & PE_F_EXEC) != 0;
}
else if (Get<uint16>(0) == PE_MACHINE_X8664) {
// COFF64/PE32+
FileType = FILETYPE_COFF;
WordSize = 64;
Executable = (Get<SCOFF_FileHeader>(0).Flags & PE_F_EXEC) != 0;
}
else if (Get<uint8>(0) == OMF_THEADR) {
// OMF 16 or 32
FileType = FILETYPE_OMF;
// Word size can only be determined by searching through records in file:
GetOMFWordSize(); // Determine word size
}
else if (Get<uint8>(0) == OMF_LIBHEAD) {
// OMF Library 16 or 32
FileType = FILETYPE_OMFLIBRARY;
}
else if ((Get<uint16>(0) & 0xFFF9) == 0x5A49) {
// DOS file or file with DOS stub
FileType = FILETYPE_DOS;
WordSize = 16;
Executable = 1;
uint32 Signature = Get<uint32>(0x3C);
if (Signature + 8 < DataSize) {
if (Get<uint16>(Signature) == 0x454E) {
// Windows 3.x file
FileType = FILETYPE_WIN3X;
}
else if (Get<uint16>(Signature) == 0x4550) {
// COFF file
uint16 MachineType = Get<uint16>(Signature + 4);
if (MachineType == PE_MACHINE_I386) {
FileType = FILETYPE_COFF;
WordSize = 32;
}
else if (MachineType == PE_MACHINE_X8664) {
FileType = FILETYPE_COFF;
WordSize = 64;
}
}
}
}
else if (namelen > 4 && stricmp(FileName + namelen - 4, ".com") == 0) {
// DOS .com file recognized only from its extension
FileType = FILETYPE_DOS;
WordSize = 16; Executable = 1;
}
else if (Get<uint16>(0) == 0 && namelen > 4 && stricmp(FileName + namelen - 4, ".obj") == 0) {
// Possibly alias record in COFF library
FileType = FILETYPE_COFF;
WordSize = 0;
Executable = 0;
}
else {
// Unknown file type
int utype = Get<uint32>(0);
err.submit(2018, utype, FileName);
FileType = 0;
}
return FileType;
}
char const * CFileBuffer::GetFileFormatName(int FileType) {
// Get name of file format type
return Lookup (FileFormatNames, FileType);
}
void CFileBuffer::SetFileType(int type) {
// Set file format type
FileType = type;
}
void CFileBuffer::Reset() {
// Set all members to zero
SetSize(0); // Deallocate memory buffer
memset(this, 0, sizeof(*this));
}
char * CFileBuffer::SetFileNameExtension(const char * f) {
// Set file name extension according to FileType
static char name[MAXFILENAMELENGTH+8];
int i;
if (strlen(f) > MAXFILENAMELENGTH) err.submit(2203, f);
strncpy(name, f, MAXFILENAMELENGTH);
// Search for last '.' in file name
for (i = (int)strlen(name)-1; i > 0; i--) if (name[i] == '.') break;
if (i < 1) {
// '.' not found. Append '.' to name
i = (int)strlen(name); if (i > MAXFILENAMELENGTH-4) i = MAXFILENAMELENGTH-4;
}
// Get default extension
if (cmd.OutputType == FILETYPE_ASM) {
strcpy(name+i, ".asm"); // Assembly file
}
else if (cmd.OutputType == FILETYPE_COFF || cmd.OutputType == FILETYPE_OMF) {
if ((FileType & (FILETYPE_LIBRARY | FILETYPE_OMFLIBRARY)) || (cmd.LibraryOptions & CMDL_LIBRARY_ADDMEMBER)) {
strcpy(name+i, ".lib"); // Windows function library
}
else {
strcpy(name+i, ".obj"); // Windows object file
}
}
else { // output type is ELF or MACHO
if ((FileType & (FILETYPE_LIBRARY | FILETYPE_OMFLIBRARY)) || (cmd.LibraryOptions & CMDL_LIBRARY_ADDMEMBER)) {
strcpy(name+i, ".a"); // Linux/BSD/Mac function library
}
else {
strcpy(name+i, ".o"); // Linux/BSD/Mac object file
}
}
return name;
}
void CFileBuffer::CheckOutputFileName() {
// Make output file name or check that requested name is valid
if (!(cmd.FileOptions & CMDL_FILE_OUTPUT)) return;
OutputFileName = cmd.OutputFile;
if (OutputFileName == 0) {
// Output file name not specified. Make filename
OutputFileName = cmd.OutputFile = SetFileNameExtension(FileName);
}
if (strcmp(FileName,OutputFileName) == 0 && !(cmd.FileOptions & CMDL_FILE_IN_OUT_SAME)) {
// Input and output files have same name
err.submit(2005, FileName);
}
}
void operator >> (CFileBuffer & a, CFileBuffer & b) {
// Transfer ownership of buffer and other properties from a to b
b.SetSize(0); // De-allocate old buffer from target if it has one
b.buffer = a.buffer; // Transfer buffer
a.buffer = 0; // Remove buffer from source, so that buffer has only one owner
// Copy properties
b.DataSize = a.GetDataSize(); // Size of data, offset to vacant space
b.BufferSize = a.GetBufferSize(); // Size of allocated buffer
b.NumEntries = a.GetNumEntries(); // Number of objects pushed
b.Executable = a.Executable; // File is executable
if (a.WordSize) b.WordSize = a.WordSize; // Segment word size (16, 32, 64)
if (a.FileName) b.FileName = a.FileName; // Name of input file
if (a.OutputFileName) b.OutputFileName = a.OutputFileName;// Name of output file
if (a.GetFileType()) b.FileType = a.GetFileType(); // Object file type
a.SetSize(0); // Reset a's properties
}
void CFileBuffer::GetOMFWordSize() {
// Determine word size for OMF file.
// There is no simple way to get the word size. Looking for odd-numbered
// record types is not sufficient. A 32-bit OMF file may use 16-bit SEGDEF
// records. We have to look for segments with the 'P' attribute set. And
// even this is not completely safe, because MASM may generate empty 32-bit
// segments so we have to look only at segments with nonzero size.
// We can still have any mixture of 16- and 32-bit segments, though, so no
// method is absolutely safe.
// We have to parse through all records in file buffer
uint8 RecordType; // Type of current record
uint32 RecordStart; // Index to start of current record
uint32 RecordEnd; // Index to end of current record
uint32 RecordLength; // Length of current record
uint32 Index = 0; // Current offset from buffer while reading
OMF_SAttrib SegAttr; // Segment attributed
uint32 SegLength; // Segment length
WordSize = 16; // WordSize = 16 if no 32 bit records found
while (Index < GetDataSize()) {
RecordStart = Index; // Record starts here
RecordType = Get<uint8>(Index++); // Get first byte of record = type
RecordLength = Get<uint16>(Index); // Next two bytes = length
Index += 2;
RecordEnd = RecordStart + RecordLength + 3;// End of record
if (RecordEnd > GetDataSize()) {
// Record goes beyond end of file
err.submit(2301); break;
}
if ((RecordType & 1) && RecordType < OMF_LIBHEAD) { // Odd-numbered type means 32 bit
WordSize = 32; // ..but this method is not safe
}
if ((RecordType & 0xFE) == OMF_SEGDEF) { // Segment definition record
SegAttr.b = Get<uint8>(Index++); // Get segment attributes
if (SegAttr.u.A == 0) {
// Frame and Offset only included if A = 0
Index += 2+1;
}
SegLength = (RecordType & 1) ? Get<uint32>(Index) : Get<uint16>(Index); // Segment length
if (SegAttr.u.P && SegLength) { // if segment has P attribute and nonzero length
WordSize = 32; // .. then it is a 32-bit segment
}
}
Index = RecordEnd; // Point to next record
}
}
// Class CTextFileBuffer is used for building text files
// Constructor
CTextFileBuffer::CTextFileBuffer() {
column = 0;
// Use UNIX linefeeds only if GASM output
LineType = (cmd.SubType == SUBTYPE_GASM) ? 1 : 0;
}
void CTextFileBuffer::Put(const char * text) {
// Write text string to buffer
uint32 len = (uint32)strlen(text); // Length of text
Push(text, len); // Add to buffer without terminating zero
column += len; // Update column
}
void CTextFileBuffer::Put(const char character) {
// Write single character to buffer
Push(&character, 1); // Add to buffer
column ++; // Update column
}
void CTextFileBuffer::NewLine() {
// Add linefeed
if (LineType == 0) {
Push("\r\n", 2); // DOS/Windows style linefeed
}
else {
Push("\n", 1); // UNIX style linefeed
}
column = 0; // Reset column
}
void CTextFileBuffer::Tabulate(uint32 i) {
// Insert spaces until column i
uint32 j;
if (i > column) { // Only insert spaces if we are not already past i
for (j = column; j < i; j++) Push(" ", 1); // Insert i - column spaces
column = i; // Update column
}
}
void CTextFileBuffer::PutDecimal(int32 x, int IsSigned) {
// Write decimal number to buffer, unsigned or signed
char text[16];
sprintf(text, IsSigned ? "%i" : "%u", x);
Put(text);
}
void CTextFileBuffer::PutHex(uint8 x, int MasmForm) {
// Write hexadecimal 8 bit number to buffer
// If MasmForm >= 1 then the function will write the number in a
// way that can be read by the assembler, e.g. 0FFH or 0xFF
char text[16];
if (MasmForm && cmd.SubType == SUBTYPE_GASM) {
// Needs 0x prefix
sprintf(text, "0x%02X", x);
Put(text);
return;
}
if (MasmForm && x >= 0xA0) {
Put("0"); // Make sure it doesn't begin with a letter
}
sprintf(text, "%02X", x);
Put(text);
if (MasmForm) Put("H");
}
void CTextFileBuffer::PutHex(uint16 x, int MasmForm) {
// Write hexadecimal 16 bit number to buffer
// If MasmForm >= 1 then the function will write the number in a
// way that can be read by the assembler, e.g. 0FFH or 0xFF
// If MasmForm == 2 then leading zeroes are stripped
char text[16];
if (MasmForm && cmd.SubType == SUBTYPE_GASM) {
// Needs 0x prefix
sprintf(text, MasmForm==1 ? "0x%04X" : "0x%X", x);
Put(text);
return;
}
sprintf(text, (MasmForm < 2) ? "%04X" : "%X", x);
// Check if leading zero needed
if (MasmForm && text[0] > '9') {
Put("0"); // Leading zero needed
}
Put(text);
if (MasmForm) Put("H");
}
void CTextFileBuffer::PutHex(uint32 x, int MasmForm) {
// Write hexadecimal 32 bit number to buffer
// If MasmForm >= 1 then the function will write the number in a
// way that can be read by the assembler, e.g. 0FFH or 0xFF
// If MasmForm == 2 then leading zeroes are stripped
char text[16];
if (MasmForm && cmd.SubType == SUBTYPE_GASM) {
// Needs 0x prefix
sprintf(text, MasmForm==1 ? "0x%08X" : "0x%X", x);
Put(text);
return;
}
sprintf(text, (MasmForm < 2) ? "%08X" : "%X", x);
// Check if leading zero needed
if (MasmForm && text[0] > '9') {
Put("0"); // Leading zero needed
}
Put(text);
if (MasmForm) Put("H");
}
void CTextFileBuffer::PutHex(uint64 x, int MasmForm) {
// Write unsigned hexadecimal 64 bit number to buffer
// If MasmForm >= 1 then the function will write the number in a
// way that can be read by the assembler, e.g. 0FFH or 0xFF
// If MasmForm == 2 then leading zeroes are stripped
char text[32];
if (MasmForm < 2) { // Print all digits
sprintf(text, "%08X%08X", HighDWord(x), uint32(x));
}
else { // Skip leading zeroes
if (HighDWord(x)) {
sprintf(text, "%X%08X", HighDWord(x), uint32(x));
}
else {
sprintf(text, "%X", uint32(x));
}
}
if (MasmForm) {
if (cmd.SubType == SUBTYPE_GASM) {
// Needs 0x prefix
Put("0x");
Put(text);
}
else {
// use 0FFH form
if (text[0] > '9') Put("0"); // Leading zero needed
Put(text);
Put("H");
}
}
else {
// write hexadecimal number only
Put(text);
}
}
void CTextFileBuffer::PutFloat(float x) {
// Write floating point number to buffer
char text[64];
sprintf(text, "%.7G", x);
Put(text);
}
void CTextFileBuffer::PutFloat(double x) {
// Write floating point number to buffer
char text[64];
sprintf(text, "%.16G", x);
Put(text);
}