URL https://opencores.org/ocsvn/forwardcom/forwardcom/trunk

Subversion Repositories forwardcom

[/] [forwardcom/] [bintools/] [emulator6.cpp] - Blame information for rev 134

Go to most recent revision | Details | Compare with Previous | View Log


/****************************  emulator6.cpp  ********************************
* Author:        Agner Fog
* date created:  2018-02-18
* Last modified: 2021-02-19
* Version:       1.11
* Project:       Binary tools for ForwardCom instruction set
* Description:
* Emulator: System functions
*
* Copyright 2018-2021 GNU General Public License http://www.gnu.org/licenses
*****************************************************************************/
 
#include "stdafx.h"
 
// Data encoding names
 
// Interrupt names
SIntTxt interruptNames[] = {
    // Error interrupts
    {INT_UNKNOWN_INST,       "Unknown instruction"},
    {INT_WRONG_PARAMETERS,       "Illegal instruction code"},
    {INT_ACCESS_READ,        "Memory read access violation"},
    {INT_ACCESS_WRITE,       "Memory write access violation"},
    {INT_ACCESS_EXE,         "Memory execute access violation"},
    {INT_CALL_STACK,         "Call stack overflow or underflow"},
    {INT_ARRAY_BOUNDS,       "Array bounds violation"},
    {INT_MISALIGNED_JUMP,    "Jump to misaligned address"},
    {INT_MISALIGNED_MEM,     "Misaligned memory address"},
 
    // Software traps. Not necessarily supported
    {INT_OVERFL_UNSIGN,      "Unsigned integer overflow"},
    {INT_OVERFL_SIGN,        "Signed integer overflow"},
    {INT_OVERFL_FLOAT,       "Floating point overflow"},
    {INT_FLOAT_INVALID,      "Floating point invalid operation"},
    {INT_FLOAT_UNDERFL,      "Floating point underflow"},
    {INT_FLOAT_NAN_LOSS,     "Floating point NAN in compare or conversion to integer"},
    {0xFFFF,                 "Filler interrupt"},
};
 
// System function names
SIntTxt systemFunctionNames[] = {
    {SYSF_EXIT,              "exit"},       // terminate program
    {SYSF_ABORT,             "abort"},      // abort program
    {SYSF_TIME,              "time"},       // time in seconds since jan 1, 1970    
 
// input/output functions
    {SYSF_PUTS,              "puts"},       // write string to stdout
    {SYSF_PUTCHAR,           "putchar"},    // write character to stdout
    {SYSF_PRINTF,            "printf"},     // write formatted output to stdout
    {SYSF_FPRINTF,           "fprintf"},    // write formatted output to file
    {SYSF_SNPRINTF,          "snprintf"},    // write formatted output to string buffer 
    {SYSF_FOPEN,             "fopen"},      //  open file
    {SYSF_FCLOSE,            "fclose"},     // SYSF_FCLOSE
    {SYSF_FREAD,             "fread"},      // read from file
    {SYSF_FWRITE,            "fwrite"},     // write to file 
    {SYSF_FFLUSH,            "fflush"},     // flush file 
    {SYSF_FEOF,              "feof"},       // check if end of file 
    {SYSF_FTELL,             "ftell"},      // get file position 
    {SYSF_FSEEK,             "fseek"},      // set file position 
    {SYSF_FERROR,            "ferror"},     // get file error    
    {SYSF_GETCHAR,           "getchar"},    // read character from stdin 
    {SYSF_FGETC,             "fgetc"},      // read character from file 
    {SYSF_FGETS,             "fgets"},      // read string from file 
    {SYSF_SCANF,             "scanf"},      // read formatted input from stdio 
    {SYSF_FSCANF,            "fscanf"},     // read formatted input from file 
    {SYSF_SSCANF,            "sscanf"},     // read formatted input from string buffer 
    {SYSF_REMOVE,            "remove"},     // delete file 
};
 
// number of entries in list
const int numSystemFunctionNames = sizeof(systemFunctionNames) / sizeof(SIntTxt);
 
 
// interrupt or trap
// To trace a runtime error, set a breakpoint here
void CThread::interrupt(uint32_t n) {
    // check if error is disabled
    uint32_t capabbit = 0;                  // bit in capabilities register
    switch (n) {
    case INT_BREAKPOINT:                    // debug breakpoint
        listOut.tabulate(emulator->disassembler.asmTab0);
        listOut.put("breakpoint");
        listOut.newLine();
        return;
    case INT_UNKNOWN_INST:                  // unknown instruction
        capabbit = 1;
        perfCounters[perf_unknown_instruction]++;
        break;
    case INT_WRONG_PARAMETERS:              // unsupported parameters for instruction
    case INT_CALL_STACK:                    // call stack overflow or underflow
        capabbit = 2;
        perfCounters[perf_wrong_operands]++;
        break;
    case INT_ACCESS_READ:                   // memory access violation, read
        capabbit = 8;
        perfCounters[perf_read_violation]++;
        break;
    case INT_ACCESS_WRITE:                  // memory access violation, write
        capabbit = 0x10;
        perfCounters[perf_write_violation]++;
        break;
    case INT_ACCESS_EXE:                    // memory access violation, execute
        capabbit = 8;
        perfCounters[perf_read_violation]++;
        break;
    case INT_ARRAY_BOUNDS:                  // array bounds overflow, unsigned
        capabbit = 4;
        perfCounters[perf_array_overflow]++;
        break;
    case INT_MISALIGNED_MEM:                // misaligned memory access.
        capabbit = 0x20;
        perfCounters[perf_misaligned]++;
        break;
    case INT_MISALIGNED_JUMP:               // jump to an address not divisible by 4
    default:
        capabbit = 0;
    }
    if (perfCounters[perf_type_of_first_error] == 0) {
        // save first error
        perfCounters[perf_type_of_first_error] = bitScanReverse(capabbit);
        uint8_t instrLength = pInstr->i[0] >> 30;  if (instrLength == 0) instrLength = 1;
        perfCounters[perf_address_of_first_error] = ((ip - ip0) >> 2) - instrLength;
    }
 
    if (!(capabilyReg[disable_errors_capability_register] & capabbit)) {
        terminate = true;                   // stop execution unless error is disabled
    }
    if (listFileName && cmd.maxLines != 0) {   // write interrupt to debug output
        listOut.tabulate(emulator->disassembler.asmTab0);
        const char * iname = Lookup(interruptNames, n);
        listOut.put(iname);
        if (terminate) listOut.put(". Terminating");
        listOut.newLine();
    }
}
 
/*
// give error message if compiled for 32 bit
void checkVa_listSize() {
    // C variable argument list va_list is not compatible with ForwardCom in 32 bit mode
    if (sizeof(void*) < 8) { // 32 bit host system. va_list has 32-bit entries except for %f
        puts("\nError: forw must be compiled in 64 bit mode. printf function may fail\n");
    }
} */
 
// check if system function has access to a particular address
uint64_t CThread::checkSysMemAccess(uint64_t address, uint64_t size, uint8_t rd, uint8_t rs, uint8_t mode) {
    // rd = register pointing to beginning of shared memory area, rs = size of shared memory area
    // mode = SHF_READ or SHF_WRITE
    // return value is possibly reduced size, or zero if no access
    if ((rd | rs) == 0) return 0;                // no access if both are r0
    uint64_t base = registers[rd];               // beginning of shared area
    uint64_t bsize = registers[rs];              // size of shared area
    if (address + size < address) size = ~address; // avoid overflow
    if (base + bsize < base) bsize = ~base;      // avoid overflow
    if ((rd & rs & 0x1F) != 0x1F) {              // share all if both are r31
        // check if within shared area
        if (address < base) return 0;
        if (address + size > base + bsize) size = base + bsize - address;
    }
    // check application's memory map
    uint32_t index = mapIndex3;
    // find index
    while (address < memoryMap[index].startAddress) {
        if (index > 0) index--;
        else return 0;
    }
    while (address >= memoryMap[index+1].startAddress) {
        if (index+2 < memoryMap.numEntries()) index++;
        else return 0;
    }
    // check read/write permission
    if ((memoryMap[index].access_addend & mode) != mode) return 0;
 
    // check if multiple map entries covered
    uint32_t index2 = index;
    while (address + size >= memoryMap[index2+1].startAddress
        && index2+2 < memoryMap.numEntries()
        && (memoryMap[index2+1].access_addend & mode) == mode) {
            index2++;
        }
    uint64_t size2 = memoryMap[index2+1].startAddress - address;  // maximum possible size
    if (size < size2) size = size2;
    return size;
}
 
// emulate fprintf with ForwardCom argument list
int CThread::fprintfEmulated(FILE * stream, const char * format, uint64_t * argumentList) {
    // a ForwardCom argument list is compatible with a va_list in 64-bit windows but not in Linux
    static CMemoryBuffer fstringbuf;             // buffer containing format string
    fstringbuf.setSize(0);                       // discard any previously stored string
    fstringbuf.pushString(format);               // copy format string
    // split the format string into substrings with a single format specifier in each
    uint32_t arg = 0;                            // argument index
    int returnValue;                             // return value;
    int returnSum = 0;                           // sum of return values;
    char * startp;                               // start of current substring in format string
    char * percentp1;                            // percent sign in current substring
    char * percentp2;                            // next percent sign starting next substring
    startp = fstringbuf.getString(0);            // start of string buffer
    percentp1 = startp;                          // search for first % sign
    while (true) {
        percentp1 = strchr(percentp1, '%');
        if (percentp1 && percentp1[1] == '%') percentp1 += 2; // skip "%%" which is not a format code
        else break;
    }
    // loop for substrings of format string containing only one format specifier each
    do {
        char c = 0;                                      // format character
        int asterisks = 0;
        bool isString = false;
        if (percentp1) {
            percentp2 = percentp1 + 1;               // search for next % sign
            while (true) {
                percentp2 = strchr(percentp2, '%');
                if (percentp2 && percentp2[1] == '%') percentp2 += 2; // skip "%%" which is not a format code
                else break;
            }
            if (percentp2) *percentp2 = 0;           // put temporary end of string at next % sign
            // check if argument is a string, and count asterisks
            int i = 1;
            while (true) {
                c = percentp1[i++];                  // read character in format specifier
                if (c == 0) break;                   // end of string
                if (c == '*') asterisks++;           // count asterisks
                c |= 0x20;                           // lower case
                if (c == 's') isString = true;       // %s means string
                if (c >= 'a' && c <= 'z') break;     // a letter terminates the format specifier
            }
        }
        else {
            percentp2 = 0;
        }
        uint64_t argument = argumentList[arg];   // The argument list can contain any type of argument with size up to 64 bits
        union {
            uint64_t a;
            double d;
        } uu;
        if (isString) argument += (uint64_t)memory; // translate string address
        // Print current argument with format substring.
        if (asterisks) { // asterisks indicate extra arguments
            if (c == 'a' || c == 'e' || c == 'f' || c == 'g') {
                // floating point argument
                if (asterisks == 1) {
                    uu.a = argumentList[arg+1];
                    returnValue = fprintf(stream, startp, argument, uu.d, argumentList[arg+2]);
                }
                else { // asterisks = 2
                    uu.a = argumentList[arg+2];
                    returnValue = fprintf(stream, startp, argument, argumentList[arg+1], uu.d);
                }
            }
            else { // integer argument
                returnValue = fprintf(stream, startp, argument, argumentList[arg+1], argumentList[arg+2]);
            }
            arg += asterisks + 1;
        }
        else {
            if (c == 'a' || c == 'e' || c == 'f' || c == 'g') {
                // floating point argument
                uu.a = argument;
                returnValue = fprintf(stream, startp, uu.d);
            }
            else {
                returnValue = fprintf(stream, startp, argument);
            }
            arg++;
        }
        if (returnValue < 0) return returnValue; // return error
        else returnSum += returnValue;           // sum of return values
        if (percentp2) *percentp2 = '%';         // re-insert next % sign
        startp = percentp1 = percentp2;
    }
    while (startp);                              // loop to next substring
    return returnSum;                            // return total number of characters written
}
 
 
// entry for system calls
void CThread::systemCall(uint32_t mod, uint32_t funcid, uint8_t rd, uint8_t rs) {
    if (listFileName) {
        // debug listing
        listOut.tabulate(emulator->disassembler.asmTab0);
        listOut.put("system call: ");
        if (mod == SYSM_SYSTEM) { // search for function name
            for (int i = 0; i < numSystemFunctionNames; i++) {
                if (systemFunctionNames[i].a == funcid) { // name is in list
                    listOut.put(systemFunctionNames[i].b);
                    goto NAME_WRITTEN;
                }
            }
        }
        // name not found. write id
        listOut.putHex(mod);  listOut.put(":");  listOut.putHex(funcid);
        NAME_WRITTEN:
        listOut.newLine();
    }
    uint64_t temp;    // temporary
    uint64_t dsize;   // data size
    const char * str = 0;    // string
    if (mod == SYSM_SYSTEM) {// system function
        // dispatch by function id
        switch (funcid) {
        case SYSF_EXIT:      // terminate program
            cmd.mainReturnValue = (int)registers[0];
            terminate = true;  break;
        case SYSF_ABORT:     // abort program
            cmd.mainReturnValue = (int)registers[0];
            terminate = true;  break;
        case SYSF_TIME:      // time
            temp = time(0);
            if (registers[0] && checkSysMemAccess(registers[0], 8, rd, rs, SHF_WRITE)) *(uint64_t*)(memory + registers[0]) = temp;
            registers[0] = temp;  break;
        case SYSF_PUTS:      // write string to stdout
            str = (const char*)memory + registers[0];
            if (strlen(str) > checkSysMemAccess(registers[0], -1, rd, rs, SHF_READ)) {
                interrupt(INT_ACCESS_READ);
            }
            else puts(str);
            break;
        case SYSF_PUTCHAR:   // write character to stdout
            putchar((char)registers[0]);
            break;
        case SYSF_PRINTF:    // write formatted output to stdout
            registers[0] = fprintfEmulated(stdout, (const char*)memory + registers[0], (uint64_t*)(memory + registers[1]));
            break;
        case SYSF_FPRINTF:   // write formatted output to file
            registers[0] = fprintfEmulated((FILE *)(registers[0]), (const char*)memory + registers[1], (uint64_t*)(memory + registers[2]));
            break;
            /*
        case SYSF_SNPRINTF:   // write formatted output to string buffer
            // this works only in 64 bit windows
            dsize = registers[1];  // size of data to read
            if (checkSysMemAccess(registers[0], dsize, rd, rs, SHF_WRITE) < dsize) {
                interrupt(INT_ACCESS_WRITE); // write access violation
                ret = 0;
            }
            else ret = snprintf((char*)memory + registers[0], registers[1], (const char*)memory + registers[2], (const char*)memory + registers[3]);
            registers[0] = ret;
            break;*/
        case SYSF_FOPEN:     //  open file
            registers[0] = (uint64_t)fopen((const char*)memory + registers[0], (const char*)memory + registers[1]);
            break;
        case SYSF_FCLOSE:    // SYSF_FCLOSE
            registers[0] = (uint64_t)fclose((FILE*)registers[0]);
            break;
        case SYSF_FREAD:     // read from file
            dsize = registers[1] * registers[2];  // size of data to read
            if (checkSysMemAccess(registers[0], dsize, rd, rs, SHF_WRITE) < dsize) {
                interrupt(INT_ACCESS_WRITE); // write access violation
                registers[0] = 0;
            }
            else registers[0] = (uint64_t)fread(memory + registers[0], (size_t)registers[1], (size_t)registers[2], (FILE *)(size_t)registers[3]);
            break;
        case SYSF_FWRITE:    // write to file 
            dsize = registers[1] * registers[2];  // size of data to write
            if (checkSysMemAccess(registers[0], dsize, rd, rs, SHF_READ) < dsize) {
                interrupt(INT_ACCESS_READ); // write access violation
                registers[0] = 0;
            }
            else registers[0] = (uint64_t)fwrite(memory + registers[0], (size_t)registers[1], (size_t)registers[2], (FILE *)(size_t)registers[3]);
            break;
        case SYSF_FFLUSH:    // flush file 
            registers[0] = (uint64_t)fflush((FILE *)registers[0]);
            break;
        case SYSF_FEOF:      // check if end of file 
            registers[0] = (uint64_t)feof((FILE *)registers[0]);
            break;
        case SYSF_FTELL:     // get file position 
            registers[0] = (uint64_t)ftell((FILE *)registers[0]);
            break;
        case SYSF_FSEEK:     // set file position 
            registers[0] = (uint64_t)fseek((FILE *)registers[0], (long int)registers[1], (int)registers[2]);
            break;
        case SYSF_FERROR:    // get file error
            registers[0] = (uint64_t)ferror((FILE *)registers[0]);
            break;
        case SYSF_GETCHAR:   // read character from stdin 
            registers[0] = (uint64_t)getchar();
            break;
        case SYSF_FGETC:     // read character from file 
            registers[0] = (uint64_t)fgetc((FILE *)registers[0]);
            break;
        case SYSF_FGETS:     // read string from file 
            dsize = registers[1];  // size of data to read
            if (checkSysMemAccess(registers[0], dsize, rd, rs, SHF_WRITE) < dsize) {
                interrupt(INT_ACCESS_WRITE); // write access violation
                registers[0] = 0;
            }
            else {
                registers[0] = (uint64_t)fgets((char *)(memory+registers[0]), (int)registers[1], (FILE *)registers[2]);
            }
            break;
        case SYSF_GETS_S:     // read string from stdin 
            dsize = registers[1];  // size of data to read
            if (checkSysMemAccess(registers[0], dsize, rd, rs, SHF_WRITE) < dsize) {
                interrupt(INT_ACCESS_WRITE); // write access violation
                registers[0] = 0;
            }
            else {
                char * r = fgets((char *)(memory+registers[0]), (int)registers[1], stdin);
                if (r == 0) registers[0] = 0;  // registers[0] unchanged if success
            }
            break;
            /*
        case SYSF_SCANF:     // read formatted input from stdio
            ret = vscanf((char *)(memory+registers[0]), (va_list)(memory + registers[1]));
            if (checkSysMemAccess(registers[0], ret, rd, rs, SHF_WRITE) < ret) {
                interrupt(INT_ACCESS_WRITE); // write access violation
            }
            registers[0] = ret;
            break;
        case SYSF_FSCANF:    // read formatted input from file
            ret = vfscanf((FILE *)registers[0], (char *)(memory+registers[1]), (va_list)(memory + registers[2]));
            if (checkSysMemAccess(registers[0], ret, rd, rs, SHF_WRITE) < ret) {
                interrupt(INT_ACCESS_WRITE); // write access violation
            }
            registers[0] = ret;
            break;
        case SYSF_SSCANF:    // read formatted input from string buffer
            ret = vsscanf((char *)(memory+registers[0]), (char *)(memory+registers[1]), (va_list)(memory + registers[2]));
            if (checkSysMemAccess(registers[0], ret, rd, rs, SHF_WRITE) < ret) {
                interrupt(INT_ACCESS_WRITE); // write access violation
            }
            registers[0] = ret;
            break; */
        case SYSF_REMOVE:    // delete file 
            registers[0] = (uint64_t)remove((char *)(memory+registers[0]));
            break;
        }
    }
}

Browse

Tools

Subversion Repositories forwardcom

[/] [forwardcom/] [bintools/] [emulator6.cpp] - Blame information for rev 134

Line No.	Rev	Author	Line
1	57	Agner	`/************************** emulator6.cpp ******************************`
2			`* Author: Agner Fog`
3			`* date created: 2018-02-18`
4			`* Last modified: 2021-02-19`
5			`* Version: 1.11`
6			`* Project: Binary tools for ForwardCom instruction set`
7			`* Description:`
8			`* Emulator: System functions`
9			`*`
10			`* Copyright 2018-2021 GNU General Public License http://www.gnu.org/licenses`
11			`*****************************************************************************/`
12
13			`#include "stdafx.h"`
14
15			`// Data encoding names`
16
17			`// Interrupt names`
18			`SIntTxt interruptNames[] = {`
19			`// Error interrupts`
20			`{INT_UNKNOWN_INST, "Unknown instruction"},`
21			`{INT_WRONG_PARAMETERS, "Illegal instruction code"},`
22			`{INT_ACCESS_READ, "Memory read access violation"},`
23			`{INT_ACCESS_WRITE, "Memory write access violation"},`
24			`{INT_ACCESS_EXE, "Memory execute access violation"},`
25			`{INT_CALL_STACK, "Call stack overflow or underflow"},`
26			`{INT_ARRAY_BOUNDS, "Array bounds violation"},`
27			`{INT_MISALIGNED_JUMP, "Jump to misaligned address"},`
28			`{INT_MISALIGNED_MEM, "Misaligned memory address"},`
29
30			`// Software traps. Not necessarily supported`
31			`{INT_OVERFL_UNSIGN, "Unsigned integer overflow"},`
32			`{INT_OVERFL_SIGN, "Signed integer overflow"},`
33			`{INT_OVERFL_FLOAT, "Floating point overflow"},`
34			`{INT_FLOAT_INVALID, "Floating point invalid operation"},`
35			`{INT_FLOAT_UNDERFL, "Floating point underflow"},`
36			`{INT_FLOAT_NAN_LOSS, "Floating point NAN in compare or conversion to integer"},`
37			`{0xFFFF, "Filler interrupt"},`
38			`};`
39
40			`// System function names`
41			`SIntTxt systemFunctionNames[] = {`
42			`{SYSF_EXIT, "exit"}, // terminate program`
43			`{SYSF_ABORT, "abort"}, // abort program`
44			`{SYSF_TIME, "time"}, // time in seconds since jan 1, 1970`
45
46			`// input/output functions`
47			`{SYSF_PUTS, "puts"}, // write string to stdout`
48			`{SYSF_PUTCHAR, "putchar"}, // write character to stdout`
49			`{SYSF_PRINTF, "printf"}, // write formatted output to stdout`
50			`{SYSF_FPRINTF, "fprintf"}, // write formatted output to file`
51			`{SYSF_SNPRINTF, "snprintf"}, // write formatted output to string buffer`
52			`{SYSF_FOPEN, "fopen"}, // open file`
53			`{SYSF_FCLOSE, "fclose"}, // SYSF_FCLOSE`
54			`{SYSF_FREAD, "fread"}, // read from file`
55			`{SYSF_FWRITE, "fwrite"}, // write to file`
56			`{SYSF_FFLUSH, "fflush"}, // flush file`
57			`{SYSF_FEOF, "feof"}, // check if end of file`
58			`{SYSF_FTELL, "ftell"}, // get file position`
59			`{SYSF_FSEEK, "fseek"}, // set file position`
60			`{SYSF_FERROR, "ferror"}, // get file error`
61			`{SYSF_GETCHAR, "getchar"}, // read character from stdin`
62			`{SYSF_FGETC, "fgetc"}, // read character from file`
63			`{SYSF_FGETS, "fgets"}, // read string from file`
64			`{SYSF_SCANF, "scanf"}, // read formatted input from stdio`
65			`{SYSF_FSCANF, "fscanf"}, // read formatted input from file`
66			`{SYSF_SSCANF, "sscanf"}, // read formatted input from string buffer`
67			`{SYSF_REMOVE, "remove"}, // delete file`
68			`};`
69
70			`// number of entries in list`
71			`const int numSystemFunctionNames = sizeof(systemFunctionNames) / sizeof(SIntTxt);`
72
73
74			`// interrupt or trap`
75			`// To trace a runtime error, set a breakpoint here`
76			`void CThread::interrupt(uint32_t n) {`
77			`// check if error is disabled`
78			`uint32_t capabbit = 0; // bit in capabilities register`
79			`switch (n) {`
80			`case INT_BREAKPOINT: // debug breakpoint`
81			`listOut.tabulate(emulator->disassembler.asmTab0);`
82			`listOut.put("breakpoint");`
83			`listOut.newLine();`
84			`return;`
85			`case INT_UNKNOWN_INST: // unknown instruction`
86			`capabbit = 1;`
87			`perfCounters[perf_unknown_instruction]++;`
88			`break;`
89			`case INT_WRONG_PARAMETERS: // unsupported parameters for instruction`
90			`case INT_CALL_STACK: // call stack overflow or underflow`
91			`capabbit = 2;`
92			`perfCounters[perf_wrong_operands]++;`
93			`break;`
94			`case INT_ACCESS_READ: // memory access violation, read`
95			`capabbit = 8;`
96			`perfCounters[perf_read_violation]++;`
97			`break;`
98			`case INT_ACCESS_WRITE: // memory access violation, write`
99			`capabbit = 0x10;`
100			`perfCounters[perf_write_violation]++;`
101			`break;`
102			`case INT_ACCESS_EXE: // memory access violation, execute`
103			`capabbit = 8;`
104			`perfCounters[perf_read_violation]++;`
105			`break;`
106			`case INT_ARRAY_BOUNDS: // array bounds overflow, unsigned`
107			`capabbit = 4;`
108			`perfCounters[perf_array_overflow]++;`
109			`break;`
110			`case INT_MISALIGNED_MEM: // misaligned memory access.`
111			`capabbit = 0x20;`
112			`perfCounters[perf_misaligned]++;`
113			`break;`
114			`case INT_MISALIGNED_JUMP: // jump to an address not divisible by 4`
115			`default:`
116			`capabbit = 0;`
117			`}`
118			`if (perfCounters[perf_type_of_first_error] == 0) {`
119			`// save first error`
120			`perfCounters[perf_type_of_first_error] = bitScanReverse(capabbit);`
121			`uint8_t instrLength = pInstr->i[0] >> 30; if (instrLength == 0) instrLength = 1;`
122			`perfCounters[perf_address_of_first_error] = ((ip - ip0) >> 2) - instrLength;`
123			`}`
124
125			`if (!(capabilyReg[disable_errors_capability_register] & capabbit)) {`
126			`terminate = true; // stop execution unless error is disabled`
127			`}`
128			`if (listFileName && cmd.maxLines != 0) { // write interrupt to debug output`
129			`listOut.tabulate(emulator->disassembler.asmTab0);`
130			`const char * iname = Lookup(interruptNames, n);`
131			`listOut.put(iname);`
132			`if (terminate) listOut.put(". Terminating");`
133			`listOut.newLine();`
134			`}`
135			`}`
136
137			`/*`
138			`// give error message if compiled for 32 bit`
139			`void checkVa_listSize() {`
140			`// C variable argument list va_list is not compatible with ForwardCom in 32 bit mode`
141			`if (sizeof(void*) < 8) { // 32 bit host system. va_list has 32-bit entries except for %f`
142			`puts("\nError: forw must be compiled in 64 bit mode. printf function may fail\n");`
143			`}`
144			`} */`
145
146			`// check if system function has access to a particular address`
147			`uint64_t CThread::checkSysMemAccess(uint64_t address, uint64_t size, uint8_t rd, uint8_t rs, uint8_t mode) {`
148			`// rd = register pointing to beginning of shared memory area, rs = size of shared memory area`
149			`// mode = SHF_READ or SHF_WRITE`
150			`// return value is possibly reduced size, or zero if no access`
151			`if ((rd \| rs) == 0) return 0; // no access if both are r0`
152			`uint64_t base = registers[rd]; // beginning of shared area`
153			`uint64_t bsize = registers[rs]; // size of shared area`
154			`if (address + size < address) size = ~address; // avoid overflow`
155			`if (base + bsize < base) bsize = ~base; // avoid overflow`
156			`if ((rd & rs & 0x1F) != 0x1F) { // share all if both are r31`
157			`// check if within shared area`
158			`if (address < base) return 0;`
159			`if (address + size > base + bsize) size = base + bsize - address;`
160			`}`
161			`// check application's memory map`
162			`uint32_t index = mapIndex3;`
163			`// find index`
164			`while (address < memoryMap[index].startAddress) {`
165			`if (index > 0) index--;`
166			`else return 0;`
167			`}`
168			`while (address >= memoryMap[index+1].startAddress) {`
169			`if (index+2 < memoryMap.numEntries()) index++;`
170			`else return 0;`
171			`}`
172			`// check read/write permission`
173			`if ((memoryMap[index].access_addend & mode) != mode) return 0;`
174
175			`// check if multiple map entries covered`
176			`uint32_t index2 = index;`
177			`while (address + size >= memoryMap[index2+1].startAddress`
178			`&& index2+2 < memoryMap.numEntries()`
179			`&& (memoryMap[index2+1].access_addend & mode) == mode) {`
180			`index2++;`
181			`}`
182			`uint64_t size2 = memoryMap[index2+1].startAddress - address; // maximum possible size`
183			`if (size < size2) size = size2;`
184			`return size;`
185			`}`
186
187			`// emulate fprintf with ForwardCom argument list`
188			`int CThread::fprintfEmulated(FILE * stream, const char * format, uint64_t * argumentList) {`
189			`// a ForwardCom argument list is compatible with a va_list in 64-bit windows but not in Linux`
190			`static CMemoryBuffer fstringbuf; // buffer containing format string`
191			`fstringbuf.setSize(0); // discard any previously stored string`
192			`fstringbuf.pushString(format); // copy format string`
193			`// split the format string into substrings with a single format specifier in each`
194			`uint32_t arg = 0; // argument index`
195			`int returnValue; // return value;`
196			`int returnSum = 0; // sum of return values;`
197			`char * startp; // start of current substring in format string`
198			`char * percentp1; // percent sign in current substring`
199			`char * percentp2; // next percent sign starting next substring`
200			`startp = fstringbuf.getString(0); // start of string buffer`
201			`percentp1 = startp; // search for first % sign`
202			`while (true) {`
203			`percentp1 = strchr(percentp1, '%');`
204			`if (percentp1 && percentp1[1] == '%') percentp1 += 2; // skip "%%" which is not a format code`
205			`else break;`
206			`}`
207			`// loop for substrings of format string containing only one format specifier each`
208			`do {`
209			`char c = 0; // format character`
210			`int asterisks = 0;`
211			`bool isString = false;`
212			`if (percentp1) {`
213			`percentp2 = percentp1 + 1; // search for next % sign`
214			`while (true) {`
215			`percentp2 = strchr(percentp2, '%');`
216			`if (percentp2 && percentp2[1] == '%') percentp2 += 2; // skip "%%" which is not a format code`
217			`else break;`
218			`}`
219			`if (percentp2) *percentp2 = 0; // put temporary end of string at next % sign`
220			`// check if argument is a string, and count asterisks`
221			`int i = 1;`
222			`while (true) {`
223			`c = percentp1[i++]; // read character in format specifier`
224			`if (c == 0) break; // end of string`
225			`if (c == '*') asterisks++; // count asterisks`
226			`c \|= 0x20; // lower case`
227			`if (c == 's') isString = true; // %s means string`
228			`if (c >= 'a' && c <= 'z') break; // a letter terminates the format specifier`
229			`}`
230			`}`
231			`else {`
232			`percentp2 = 0;`
233			`}`
234			`uint64_t argument = argumentList[arg]; // The argument list can contain any type of argument with size up to 64 bits`
235			`union {`
236			`uint64_t a;`
237			`double d;`
238			`} uu;`
239			`if (isString) argument += (uint64_t)memory; // translate string address`
240			`// Print current argument with format substring.`
241			`if (asterisks) { // asterisks indicate extra arguments`
242			`if (c == 'a' \|\| c == 'e' \|\| c == 'f' \|\| c == 'g') {`
243			`// floating point argument`
244			`if (asterisks == 1) {`
245			`uu.a = argumentList[arg+1];`
246			`returnValue = fprintf(stream, startp, argument, uu.d, argumentList[arg+2]);`
247			`}`
248			`else { // asterisks = 2`
249			`uu.a = argumentList[arg+2];`
250			`returnValue = fprintf(stream, startp, argument, argumentList[arg+1], uu.d);`
251			`}`
252			`}`
253			`else { // integer argument`
254			`returnValue = fprintf(stream, startp, argument, argumentList[arg+1], argumentList[arg+2]);`
255			`}`
256			`arg += asterisks + 1;`
257			`}`
258			`else {`
259			`if (c == 'a' \|\| c == 'e' \|\| c == 'f' \|\| c == 'g') {`
260			`// floating point argument`
261			`uu.a = argument;`
262			`returnValue = fprintf(stream, startp, uu.d);`
263			`}`
264			`else {`
265			`returnValue = fprintf(stream, startp, argument);`
266			`}`
267			`arg++;`
268			`}`
269			`if (returnValue < 0) return returnValue; // return error`
270			`else returnSum += returnValue; // sum of return values`
271			`if (percentp2) *percentp2 = '%'; // re-insert next % sign`
272			`startp = percentp1 = percentp2;`
273			`}`
274			`while (startp); // loop to next substring`
275			`return returnSum; // return total number of characters written`
276			`}`
277
278
279			`// entry for system calls`
280			`void CThread::systemCall(uint32_t mod, uint32_t funcid, uint8_t rd, uint8_t rs) {`
281			`if (listFileName) {`
282			`// debug listing`
283			`listOut.tabulate(emulator->disassembler.asmTab0);`
284			`listOut.put("system call: ");`
285			`if (mod == SYSM_SYSTEM) { // search for function name`
286			`for (int i = 0; i < numSystemFunctionNames; i++) {`
287			`if (systemFunctionNames[i].a == funcid) { // name is in list`
288			`listOut.put(systemFunctionNames[i].b);`
289			`goto NAME_WRITTEN;`
290			`}`
291			`}`
292			`}`
293			`// name not found. write id`
294			`listOut.putHex(mod); listOut.put(":"); listOut.putHex(funcid);`
295			`NAME_WRITTEN:`
296			`listOut.newLine();`
297			`}`
298			`uint64_t temp; // temporary`
299			`uint64_t dsize; // data size`
300			`const char * str = 0; // string`
301			`if (mod == SYSM_SYSTEM) {// system function`
302			`// dispatch by function id`
303			`switch (funcid) {`
304			`case SYSF_EXIT: // terminate program`
305			`cmd.mainReturnValue = (int)registers[0];`
306			`terminate = true; break;`
307			`case SYSF_ABORT: // abort program`
308			`cmd.mainReturnValue = (int)registers[0];`
309			`terminate = true; break;`
310			`case SYSF_TIME: // time`
311			`temp = time(0);`
312			`if (registers[0] && checkSysMemAccess(registers[0], 8, rd, rs, SHF_WRITE)) (uint64_t)(memory + registers[0]) = temp;`
313			`registers[0] = temp; break;`
314			`case SYSF_PUTS: // write string to stdout`
315			`str = (const char*)memory + registers[0];`
316			`if (strlen(str) > checkSysMemAccess(registers[0], -1, rd, rs, SHF_READ)) {`
317			`interrupt(INT_ACCESS_READ);`
318			`}`
319			`else puts(str);`
320			`break;`
321			`case SYSF_PUTCHAR: // write character to stdout`
322			`putchar((char)registers[0]);`
323			`break;`
324			`case SYSF_PRINTF: // write formatted output to stdout`
325			`registers[0] = fprintfEmulated(stdout, (const char)memory + registers[0], (uint64_t)(memory + registers[1]));`
326			`break;`
327			`case SYSF_FPRINTF: // write formatted output to file`
328			`registers[0] = fprintfEmulated((FILE )(registers[0]), (const char)memory + registers[1], (uint64_t*)(memory + registers[2]));`
329			`break;`
330			`/*`
331			`case SYSF_SNPRINTF: // write formatted output to string buffer`
332			`// this works only in 64 bit windows`
333			`dsize = registers[1]; // size of data to read`
334			`if (checkSysMemAccess(registers[0], dsize, rd, rs, SHF_WRITE) < dsize) {`
335			`interrupt(INT_ACCESS_WRITE); // write access violation`
336			`ret = 0;`
337			`}`
338			`else ret = snprintf((char)memory + registers[0], registers[1], (const char)memory + registers[2], (const char*)memory + registers[3]);`
339			`registers[0] = ret;`
340			`break;*/`
341			`case SYSF_FOPEN: // open file`
342			`registers[0] = (uint64_t)fopen((const char)memory + registers[0], (const char)memory + registers[1]);`
343			`break;`
344			`case SYSF_FCLOSE: // SYSF_FCLOSE`
345			`registers[0] = (uint64_t)fclose((FILE*)registers[0]);`
346			`break;`
347			`case SYSF_FREAD: // read from file`
348			`dsize = registers[1] * registers[2]; // size of data to read`
349			`if (checkSysMemAccess(registers[0], dsize, rd, rs, SHF_WRITE) < dsize) {`
350			`interrupt(INT_ACCESS_WRITE); // write access violation`
351			`registers[0] = 0;`
352			`}`
353			`else registers[0] = (uint64_t)fread(memory + registers[0], (size_t)registers[1], (size_t)registers[2], (FILE *)(size_t)registers[3]);`
354			`break;`
355			`case SYSF_FWRITE: // write to file`
356			`dsize = registers[1] * registers[2]; // size of data to write`
357			`if (checkSysMemAccess(registers[0], dsize, rd, rs, SHF_READ) < dsize) {`
358			`interrupt(INT_ACCESS_READ); // write access violation`
359			`registers[0] = 0;`
360			`}`
361			`else registers[0] = (uint64_t)fwrite(memory + registers[0], (size_t)registers[1], (size_t)registers[2], (FILE *)(size_t)registers[3]);`
362			`break;`
363			`case SYSF_FFLUSH: // flush file`
364			`registers[0] = (uint64_t)fflush((FILE *)registers[0]);`
365			`break;`
366			`case SYSF_FEOF: // check if end of file`
367			`registers[0] = (uint64_t)feof((FILE *)registers[0]);`
368			`break;`
369			`case SYSF_FTELL: // get file position`
370			`registers[0] = (uint64_t)ftell((FILE *)registers[0]);`
371			`break;`
372			`case SYSF_FSEEK: // set file position`
373			`registers[0] = (uint64_t)fseek((FILE *)registers[0], (long int)registers[1], (int)registers[2]);`
374			`break;`
375			`case SYSF_FERROR: // get file error`
376			`registers[0] = (uint64_t)ferror((FILE *)registers[0]);`
377			`break;`
378			`case SYSF_GETCHAR: // read character from stdin`
379			`registers[0] = (uint64_t)getchar();`
380			`break;`
381			`case SYSF_FGETC: // read character from file`
382			`registers[0] = (uint64_t)fgetc((FILE *)registers[0]);`
383			`break;`
384			`case SYSF_FGETS: // read string from file`
385			`dsize = registers[1]; // size of data to read`
386			`if (checkSysMemAccess(registers[0], dsize, rd, rs, SHF_WRITE) < dsize) {`
387			`interrupt(INT_ACCESS_WRITE); // write access violation`
388			`registers[0] = 0;`
389			`}`
390			`else {`
391			`registers[0] = (uint64_t)fgets((char )(memory+registers[0]), (int)registers[1], (FILE )registers[2]);`
392			`}`
393			`break;`
394			`case SYSF_GETS_S: // read string from stdin`
395			`dsize = registers[1]; // size of data to read`
396			`if (checkSysMemAccess(registers[0], dsize, rd, rs, SHF_WRITE) < dsize) {`
397			`interrupt(INT_ACCESS_WRITE); // write access violation`
398			`registers[0] = 0;`
399			`}`
400			`else {`
401			`char * r = fgets((char *)(memory+registers[0]), (int)registers[1], stdin);`
402			`if (r == 0) registers[0] = 0; // registers[0] unchanged if success`
403			`}`
404			`break;`
405			`/*`
406			`case SYSF_SCANF: // read formatted input from stdio`
407			`ret = vscanf((char *)(memory+registers[0]), (va_list)(memory + registers[1]));`
408			`if (checkSysMemAccess(registers[0], ret, rd, rs, SHF_WRITE) < ret) {`
409			`interrupt(INT_ACCESS_WRITE); // write access violation`
410			`}`
411			`registers[0] = ret;`
412			`break;`
413			`case SYSF_FSCANF: // read formatted input from file`
414			`ret = vfscanf((FILE )registers[0], (char )(memory+registers[1]), (va_list)(memory + registers[2]));`
415			`if (checkSysMemAccess(registers[0], ret, rd, rs, SHF_WRITE) < ret) {`
416			`interrupt(INT_ACCESS_WRITE); // write access violation`
417			`}`
418			`registers[0] = ret;`
419			`break;`
420			`case SYSF_SSCANF: // read formatted input from string buffer`
421			`ret = vsscanf((char )(memory+registers[0]), (char )(memory+registers[1]), (va_list)(memory + registers[2]));`
422			`if (checkSysMemAccess(registers[0], ret, rd, rs, SHF_WRITE) < ret) {`
423			`interrupt(INT_ACCESS_WRITE); // write access violation`
424			`}`
425			`registers[0] = ret;`
426			`break; */`
427			`case SYSF_REMOVE: // delete file`
428			`registers[0] = (uint64_t)remove((char *)(memory+registers[0]));`
429			`break;`
430			`}`
431			`}`
432			`}`