Subversion Repositories forwardcom

/****************************  main.cpp   *******************************
* Author:        Agner Fog
* Date created:  2017-04-17
* Last modified: 2020-11-25
* Version:       1.11
* Project:       Binary tools for ForwardCom instruction set
* Description:   This includes assembler, disassembler, linker, library
*                manager, and emulator in one program
*
* Instructions:
* Run with option -h for help
*
* For detailed instructions, see forwardcom.pdf
*
* (c) Copyright 2017-2020 GNU General Public License version 3
* http://www.gnu.org/licenses
*****************************************************************************/
 
#include "stdafx.h"
 
// Check if running on little endian system
static void CheckEndianness();
 
// Buffer for symbol names is made global in order to make it accessible to operators:
// bool operator < (ElfFWC_Sym2 const &, ElfFWC_Sym2 const &)
// bool operator < (SStringEntry const & a, SStringEntry const & b)
// bool operator < (SSymbolEntry const & a, SSymbolEntry const & b)
CTextFileBuffer symbolNameBuffer;      // Buffer for symbol names during assembly, linking, and library operations
 
 
                                       // Main. Program starts here
int main(int argc, char * argv[]) {
    CheckEndianness();                  // Check that machine is little-endian
 
#ifdef  _DEBUG
   // For debugging only: Read command line from file resp.txt
    if (argc == 1) {
        char commandline[] = "@resp.txt";
        char * dummyarg[] = { argv[0],  commandline};
        argc = 2; argv = dummyarg;
    }
#endif
 
    cmd.readCommandLine(argc, argv);             // Read command line parameters   
    if (cmd.job == CMDL_JOB_HELP) return 0;      // Help screen has been printed. Do nothing else
 
    CConverter maincvt;                          // This object takes care of all conversions etc.
    maincvt.go();                                // Do everything the command line says
 
    if (cmd.verbose && cmd.job != CMDL_JOB_EMU)  printf("\n"); // End with newline
    if (err.getWorstError()) cmd.mainReturnValue = err.getWorstError(); // Return with error code
    return cmd.mainReturnValue;
}
 
 
CConverter::CConverter() {
    // Constructor
}
 
void CConverter::go() {
    // Do whatever the command line parameters say
 
    switch (cmd.job) {
    case CMDL_JOB_DUMP:
        // File dump requested
        readInputFile();
        if (err.number()) return;
        switch (fileType) {
        case FILETYPE_FWC: case FILETYPE_ELF:
            dumpELF();  break;
        default:
            err.submit(ERR_DUMP_NOT_SUPPORTED, getFileFormatName(fileType));  // Dump of this file type not supported
        }
        printf("\n");                              // New line
        break;
 
    case CMDL_JOB_ASS:
        // assemble
        readInputFile();
        if (err.number()) return;
        assemble();
        break;
 
    case CMDL_JOB_DIS:
        // disassemble
        readInputFile();
        if (err.number()) return;
        disassemble();
        break;
 
    case CMDL_JOB_LINK:
    case CMDL_JOB_RELINK:        
        link();          // linker
        break;
 
    case CMDL_JOB_LIB:
        readInputFile();
        if (err.number()) return;
        lib();        // library manager
        break;
 
    case CMDL_JOB_EMU:
        emulate();    // emulator
        break;
 
    case 0: return; // no job. command line error
 
    default:
        err.submit(ERR_INTERNAL);
    }
}
 
// read input file
void CConverter::readInputFile() {
    // Ignore nonexisting filename when building library
    int IgnoreError = (cmd.fileOptions & CMDL_FILE_IN_IF_EXISTS);
    // Read input file
    read(cmd.getFilename(cmd.inputFile), IgnoreError);
    if (cmd.job == CMDL_JOB_ASS) fileType = FILETYPE_ASM;
    else getFileType();                 // Determine file type
    if (err.number()) return;           // Return if error
    cmd.inputType = fileType;           // Save input file type in cmd for access from other modules
    if (cmd.outputType == 0) {
        // desired type not specified
        cmd.outputType = fileType;
    }
}
 
void CConverter::dumpELF() {
    // Dump ELF file
    // Make object for interpreting 32 bit ELF file
    CELF elf;
    *this >> elf;                      // Give it my buffer
    elf.parseFile();                   // Parse file buffer
    if (err.number()) return;          // Return if error
    elf.dump(cmd.dumpOptions);         // Dump file
    *this << elf;                      // Take back my buffer
}
 
void CConverter::assemble() {
    // Aassemble to ELF file
    // Make instance of assembler
    CAssembler ass;
    if (err.number()) return;
    *this >> ass;                      // Give it my buffer
    ass.go();                          // run
} 
 
void CConverter::disassemble() {
    // Disassemble ELF file
    // Make instance of disassembler
    CDisassembler dis;
    if (err.number()) return;
    *this >> dis;                      // Give it my buffer
    dis.parseFile();                   // Parse file buffer
    if (err.number()) return;          // Return if error
    dis.getComponents1();              // Get components from ELF file
    dis.go();                          // Convert
}
 
void CConverter::lib() {
    // Library manager
    // Make instance of library manager
    CLibrary libmanager;
    if (err.number()) return;
    *this >> libmanager;               // Give it my buffer
    libmanager.go();                   // Do the job
}
 
void CConverter::link() {
    // Linker
    // Make instance of linker
    CLinker linker;
    linker.go();                   // Do the job
}
 
void CConverter::emulate() {
    // Emulator
    // Make instance of linker
    CEmulator emulator;
    emulator.go();                   // Do the job
}
 
// Convert half precision floating point number to single precision
// Optional support for subnormals
// NAN payload is right-justified for ForwardCom
float half2float(uint32_t half, bool supportSubnormal) {
    union {
        uint32_t hhh;
        float fff;
        struct {
            uint32_t mant: 23;
            uint32_t expo:  8;
            uint32_t sign:  1;
        };
    } u;
 
    u.hhh  = (half & 0x7fff) << 13;              // Exponent and mantissa
    u.hhh += 0x38000000;                         // Adjust exponent bias
    if ((half & 0x7C00) == 0) {// Subnormal
        if (supportSubnormal) {
            u.hhh = 0x3F800000 - (24 << 23);     // 2^-24
            u.fff *= int(half & 0x3FF);          // subnormal value = mantissa * 2^-24
        }
        else {        
            u.hhh = 0;                           // make zero
        }
    }
    if ((half & 0x7C00) == 0x7C00) {             // infinity or nan
        u.expo = 0xFF;
        if (half & 0x3FF) {  // nan
            u.mant = 1 << 22 | (half & 0x1FF);   // NAN payload is right-justified only in ForwardCom
        }
    }
    u.hhh |= (half & 0x8000) << 16;              // sign bit
    return u.fff;
}
 
// Convert floating point number to half precision.
// Round to nearest or even. 
// Optional support for subnormals
// NAN payload is right-justified
uint16_t float2half(float x, bool supportSubnormal) {
    union {                                      // single precision float
        float f;
        struct {
            uint32_t mant: 23;
            uint32_t expo:  8;
            uint32_t sign:  1;
        };
    } u;
    union {                                      // half precision float
        uint16_t h;
        struct {
            uint16_t mant: 10;
            uint16_t expo:  5;
            uint16_t sign:  1;
        };
    } v;
    u.f = x;
    v.sign = u.sign;
    v.mant = u.mant >> 13;                       // get upper part of mantissa
    if (u.mant & (1 << 12)) {                    // round to nearest or even
        if ((u.mant & ((1 << 12) - 1)) || (v.mant & 1)) { // round up if odd or remaining bits are nonzero
            v.h++;                               // overflow here will give infinity
        }
    }
    v.expo = u.expo - 0x70;
    if (u.expo == 0xFF) {                        // infinity or nan
        v.expo = 0x1F;
        if (u.mant != 0) {                       // Nan
            v.mant = (u.mant & 0x1FF) | 0x200;   // NAN payload is right-justified only in ForwardCom        
        }
    }
    else if (u.expo > 0x8E) {
        v.expo = 0x1F;  v.mant = 0;              // overflow -> inf
    }
    else if (u.expo < 0x71) {
        v.expo = 0;
        if (supportSubnormal) {
            u.expo += 24;
            u.sign = 0;
            v.mant = int(u.f) & 0x3FF;
        }
        else {        
            v.mant = 0;                          // underflow -> 0
        }
    }
    return v.h;   
}
 
// Convert double precision floating point number to half precision. 
// subnormals optionally supported
// Nan payloads not preserved
uint16_t double2half(double x, bool supportSubnormal) {
    union {
        double d;
        struct {
            uint64_t mant: 52;
            uint64_t expo: 11;
            uint64_t sign:  1;
        };
    } u;
    union {
        uint16_t h;
        struct {
            uint16_t mant: 10;
            uint16_t expo:  5;
            uint16_t sign:  1;
        };
    } v;
    u.d = x;
    v.mant = u.mant >> 42;                       // get upper part of mantissa
    if (u.mant & ((uint64_t)1 << 41)) {          // round to nearest or even
        if ((u.mant & (((uint64_t)1 << 41) - 1)) || (v.mant & 1)) { // round up if odd or remaining bits are nonzero
            v.h++;                               // overflow here will give infinity
        }
    }
    v.expo = u.expo - 0x3F0;
    v.sign = u.sign;
    if (u.expo == 0x7FF) {
        v.expo = 0x1F;                           // infinity or nan
        if (u.mant != 0 && v.mant == 0) v.mant = 0x200;  // make sure output is a nan if input is nan
    }
    else if (u.expo > 0x40E) {
        v.expo = 0x1F;  v.mant = 0;              // overflow -> inf
    }
    else if (u.expo < 0x3F1) {                   // underflow
        v.expo = 0;
        if (supportSubnormal) {
            u.expo += 24;
            u.sign = 0;
            v.mant = int(u.d) & 0x3FF;
        }
        else {        
            v.mant = 0;                          // underflow -> 0
        }
    }
    return v.h;   
}
 
 
// Check that we are running on a machine with little-endian memory 
// organization and right data representation
static void CheckEndianness() {
    static uint8_t bytes[4] = { 1, 2, 3, 0xC0 };
    uint8_t * bb = bytes;
    if (*(uint32_t*)bb != 0xC0030201) {
        err.submit(ERR_BIG_ENDIAN);        // Big endian
    }
    if (*(int32_t*)bb != -1073544703) {
        err.submit(ERR_BIG_ENDIAN);        // not two's complement
    }
    *(float*)bb = 1.0f;
    if (*(uint32_t*)bb != 0x3F800000) {
        err.submit(ERR_BIG_ENDIAN);        // Not IEEE floating point format
    }
}
 
 
// Bit scan reverse. Returns floor(log2(x)), 0 if x = 0
uint32_t bitScanReverse(uint64_t x) {
    uint32_t s = 32;  // shift count
    uint32_t r = 0;   // return value
    uint64_t y;       // x >> s
    do {
        y = x >> s;
        if (y) {
            r += s;
            x = y;
        }
        s >>= 1;
    }
    while (s);
    return r;
}
 
// Bit scan forward. Returns index to the lowest set bit, 0 if x = 0
uint32_t bitScanForward(uint64_t x) {
    uint32_t s = 32;  // shift count
    uint32_t r = 0;   // return value
    if (x == 0) return 0;
    do {
        if ((x & (((uint64_t)1 << s) - 1)) == 0) {
            x >>= s;
            r += s;
        }
        s >>= 1;
    }
    while (s);
    return r;
}
 
const char * timestring(uint32_t t) {
    // Convert 32 bit time stamp to string
    // Fix the problem that time_t may be 32 bit or 64 bit
    union {
        time_t t;
        uint32_t t32;
    } utime;
    utime.t = 0;
    utime.t32 = t;
    const char * string = ctime(&utime.t);
    if (string == 0) string = "?";
    return string;
}