Initial commit

src/device.c

@@ -4,26 +4,29 @@
 #include <string.h>
 
 #include "device.h"
+#include "libhmmmm/mem.h"
 #include "mem.h"
 #include "mem_seg.h"
 #include "runner.h"
+#include "instr.h"
 #include "addrs.h"
 
 
 uint64_t memSegToGlobal(device_specs_t* spec, uint8_t seg, uint64_t localaddr)
 {
-    uint64_t offset = 0;
-    for (uint8_t i = 0; i < seg; i++)
-    {
-        offset += spec->memSpecs[i]->len * spec->memSpecs[i]->wordLen;
-    }
-    return offset + localaddr;
+    // uint64_t offset = 0;
+    // for (uint8_t i = 0; i < seg; i++)
+    // {
+    //     offset += spec->memSpecs[i]->len * spec->memSpecs[i]->wordLen;
+    // }
+    return spec->memSpecs[seg]->start + localaddr;
 }
 
 
 void freeDevMem(device_mem_t* devMem)
 {
     free(devMem->memsegShifts);
+    free(devMem->memsegSizes);
     free(devMem->rawCells);
     free(devMem->memreadCellAddrs);
     free(devMem->memwriteCellAddrs);
@@ -62,7 +65,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
     uint64_t memTotalSize = 0;
     for (uint8_t i = 0; i < devSpec->memSpecsCount; i++)
     {
-        size_t tmp = devSpec->memSpecs[i]->start + devSpec->memSpecs[i]->len * devSpec->memSpecs[i]->wordLen;
+        size_t tmp = devSpec->memSpecs[i]->start + (devSpec->memSpecs[i]->len * devSpec->memSpecs[i]->wordLen);
         if (memTotalSize < tmp)
         {
             memTotalSize = tmp;
@@ -72,7 +75,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
     void* rawCells = (void*)calloc(memTotalSize, sizeof(void*));
     if (rawCells == NULL)
     {
-        sprintf(errbuf, "unable to allocate raw memory buf");
+        sprintf(errbuf, "unable to allocate raw memory buf %lu bytes", memTotalSize);
         free(devMem);
         return NULL;
     }
@@ -103,11 +106,6 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
         return NULL;
     }
 
-    for (uint8_t i = 0; i < devSpec->memSpecsCount; i++)
-    {
-        cells[i] = (void*)((size_t)rawCells + (size_t)devSpec->memSpecs[i]->start);
-    }
-
     char** cellNames = calloc(devSpec->memSpecsCount, sizeof(char*));
 
     if(cellNames == NULL)
@@ -122,7 +120,15 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
 
     for(size_t i = 0; i < devSpec->memSpecsCount; i++)
     {
+        // cellNames[i] = devSpec->memSpecs[i]->name;
+    }
+
+    for (uint8_t i = 0; i < devSpec->memSpecsCount; i++)
+    {
+        printf("init seg \"%s\": %lu:%lu\n", devSpec->memSpecs[i]->name, devSpec->memSpecs[i]->start, devSpec->memSpecs[i]->len);
+        cells[i] = &(((uint8_t*)rawCells)[devSpec->memSpecs[i]->start]);
         cellNames[i] = devSpec->memSpecs[i]->name;
+        // cells[i] = (void*)((size_t)rawCells + (size_t)devSpec->memSpecs[i]->start);
     }
 
     uint64_t* memreadCellAddrs = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint64_t));
@@ -260,13 +266,34 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
         return NULL;
     }
 
+    uint64_t* memsegSizes = calloc(devSpec->memSpecsCount, sizeof(uint64_t));
+    if(memsegSizes == NULL)
+    {
+
+        sprintf(errbuf, "unable to allocate write interception handlers");
+        free(smartAddrWriteHandlers);
+        free(smartAddrReadHandlers);
+        free(devMem->memsegShifts);
+        free(devMem);
+        free(rawCells);
+        free(memreadCellAddrs);
+        free(memwriteCellAddrs);
+        free(memwriteCellSegments);
+        free(memwriteValues);
+        free(memwriteValuesContainers);
+        free(memwriteWordLengths);
+        free(cells);
+        free(cellNames);
+        return NULL;
+    }
+
 
     for(uint64_t i = 0; i < memTotalSize; i++) 
     {
-        smartAddrReadHandlers[i].func = default_addr_read_handler;
+        smartAddrReadHandlers[i].func = NULL;
         smartAddrReadHandlers[i].ident = 0;
 
-        smartAddrWriteHandlers[i].func = default_addr_write_handler;
+        smartAddrWriteHandlers[i].func = NULL;
         smartAddrWriteHandlers[i].ident = 0;
     }
 
@@ -275,7 +302,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
     {
         if((i & smartAddrReadMask) == smartAddrReadMask)
         {
-            smartAddrReadHandlers[i].func = default_addr_read_handler;
+            smartAddrReadHandlers[i].func = NULL;
         }
     }
 
@@ -337,12 +364,36 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
     devMem->smartAddrWriteMask = smartAddrWriteMask;
     devMem->smartAddrWriteHandlers = smartAddrWriteHandlers;
     devMem->memsegNames = cellNames;
+    devMem->memsegSizes = memsegSizes;
 
-    for(uint8_t i = 0; i < devSpec->memSpecsCount; i++)
+    memseg_metadata_t requiredSegments[] = MEMSEG_DEFINES;
+
+    for (uint8_t i = 0; i < devSpec->memSpecsCount; i++)
     {
-        devMem->memsegShifts[i] = memSegToGlobal(devSpec, i, 0);
+
+        for(uint8_t j = 0; j < sizeof(requiredSegments) / sizeof(memseg_metadata_t); j++)
+        {
+            const memseg_metadata_t seg_def = requiredSegments[j];
+
+            if(strcmp(seg_def.name, devSpec->memSpecs[i]->name) == 0)
+            {
+                const uint8_t seg_id = seg_def.seg_id;
+                devMem->memsegShifts[seg_id] = memSegToGlobal(devSpec, i, 0);
+                devMem->memsegSizes[seg_id] = devSpec->memSpecs[i]->len;
+                printf("set mem segment %d meta: +%lu/%lu \n", seg_id, devMem->memsegShifts[j], devMem->memsegSizes[j]);
+            }
+        }
     }
 
+
+    // for(uint8_t i = 0; i < devSpec->memSpecsCount; i++)
+    // {
+    //     devMem->memsegShifts[i] = memSegToGlobal(devSpec, i, 0);
+    //     devMem->memsegSizes[i] = devSpec->memSpecs[i]->len;
+    // }
+
+    setOpcodeSizes((uint8_t*)(devMem->cells[MEMDATA_OPSIZE]));
+
     return devMem;
 }
 
@@ -350,7 +401,13 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
 uint8_t makeDeviceTick(device_public_context_t* devContext)
 {
     device_info_t* devInfo = (device_info_t*)devContext->deviceInfo;
-    return makeTick(devInfo->deviceMem);
+    prog_counter_t _pc;
+    READ_MEM(_pc, devInfo->deviceMem, MEMSEG_PC_SEG_NUM, MEMSEG_PC_ADDR, prog_counter_t)
+    // printf("old PC is %d\n", _pc);
+    uint8_t ticks = makeTick(&_pc, devInfo->instr, devInfo->deviceMem);
+    WRITE_MEM(devInfo->deviceMem, MEMSEG_PC_SEG_NUM, MEMSEG_PC_ADDR, prog_counter_t, _pc);
+    // printf("new PC is %d\n", _pc);
+    return ticks;
 }
 
 device_info_t* initSpecs(device_specs_t* specs, char* errbuf)
@@ -372,9 +429,25 @@ device_info_t* initSpecs(device_specs_t* specs, char* errbuf)
         return NULL;
     }
 
+    devInfo->pc = &((prog_counter_t*)(devMem->cells[MEMSEG_PC_SEG_NUM]))[MEMSEG_PC_ADDR];
+    *(devInfo->pc) = 0;
     devInfo->specs = specs;
+
     devInfo->deviceMem = devMem;
 
+
+    instr_h_func* instrs = genInstrArray(genErrBuf);
+
+    if (instrs == NULL)
+    {
+        sprintf(errbuf, "unable to initialize instructions: %s", genErrBuf);
+        freeDevMem(devInfo->deviceMem);
+        free(devInfo);
+        return NULL;
+    }
+
+    devInfo->instr = instrs;
+
     return devInfo;
 }
 
@@ -417,6 +490,8 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
         specCount++;
     }
 
+    const uint8_t providedSpecCount = specCount;
+
     if(specCount < sizeof(requiredSegments)/sizeof(memseg_metadata_t))
     {
         specCount = sizeof(requiredSegments)/sizeof(memseg_metadata_t);
@@ -468,7 +543,7 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
 
     uint8_t executableSegmentsFound = 0;
 
-    for (uint8_t i = 0; i < specCount; i++)
+    for (uint8_t i = 0; i < providedSpecCount; i++)
     {
         uint8_t specNum = 0xFF;
         uint8_t is_error = 0;
@@ -478,8 +553,9 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
         {
             const memseg_metadata_t seg_def = requiredSegments[j];
 
-            if(strcmp(seg_def.name, segments[i]->name))
+            if(strcmp(seg_def.name, segments[i]->name) == 0)
             {
+                printf("found seg \"%s\"\n", seg_def.name);
                 const uint8_t is_found = requiredSegmentsFoundMap[j];
                 if(is_found)
                 {
@@ -490,8 +566,9 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
                 {
                     if(seg_def.is_executable == segments[i]->isExecutable || segments[i]->isExecutable)
                     {
+                        printf("seg executable req satisfyed (%d)\n", seg_def.is_executable);
                         requiredSegmentsFoundMap[j] = 1;
-                        specNum = j;
+                        specNum = seg_def.seg_id;
                         seek_found = 1;
                     }
                     else
@@ -516,7 +593,7 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
             free(requiredSegmentsFoundMap);
             return NULL;
         }
-        specs->memSpecs[specNum]->name = calloc(strlen(segments[i]->name), sizeof(char));
+        specs->memSpecs[specNum]->name = calloc(strlen(segments[i]->name) + 1, sizeof(char));
         if(specs->memSpecs[specNum]->name == NULL)
         {
             sprintf(errbuf, "unable to allocate spec %d name", i);
@@ -529,6 +606,7 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
         specs->memSpecs[specNum]->start = segments[i]->start;
         specs->memSpecs[specNum]->len = segments[i]->len;
         specs->memSpecs[specNum]->wordLen = segments[i]->wordLen;
+        printf("set segment %s :%lu->%lu/%d\n", segments[i]->name, segments[i]->start, segments[i]->len, segments[i]->wordLen);
         if(segments[i]->isExecutable)
         {
             specs->executableSegments[executableSegmentsFound] = specNum;
@@ -541,12 +619,13 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
         if(requiredSegmentsFoundMap[i] == 0)
         {
             const memseg_metadata_t seg_def = requiredSegments[i];
+            printf("found segment that not specified: \"%s\"\n", seg_def.name);
 
             specs->memSpecs[seg_def.seg_id]->start = seg_def.default_addr;
             specs->memSpecs[seg_def.seg_id]->len = seg_def.default_size;
             specs->memSpecs[seg_def.seg_id]->wordLen = seg_def.word_len;
 
-            specs->memSpecs[seg_def.seg_id]->name = calloc(strlen(seg_def.name), sizeof(char));
+            specs->memSpecs[seg_def.seg_id]->name = calloc(strlen(seg_def.name) + 1, sizeof(char));
 
             if(specs->memSpecs[seg_def.seg_id]->name == NULL)
             {
@@ -575,6 +654,8 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
         return NULL;
     }
 
+    printf("set all segments\n");
+
     #ifdef MEMSEG_PC_SEG_NUM 
         #ifndef MEMSEG_PC_ADDR
             specs->pcAddr = memSegToGlobal(specs, MEMSEG_PC_SEG_NUM, 0);
@@ -584,6 +665,7 @@ device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf)
     #endif
     free(requiredSegmentsFoundMap);
 
+    printf("parse specs done\n");
     return specs;
 }
 
@@ -670,14 +752,21 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
     specs->smartWriteSpecs = smartWriteSpecs;
     specs->smartWriteSpecsCount = smartWriteSpecsCount;
 
-    specs->memSpecs[0]->len = 255;
+    specs->memSpecs[0]->len = 1024;
     specs->memSpecs[0]->start = 0;
-    specs->memSpecs[0]->wordLen = 1;
+    specs->memSpecs[0]->wordLen = OPCODE_WORDSIZE;
 
-    specs->memSpecs[1]->len = 1;
-    specs->memSpecs[1]->start = 256;
-    specs->memSpecs[1]->wordLen = 1;
+    specs->memSpecs[1]->len = 32;
+    specs->memSpecs[1]->start = (1024 * OPCODE_WORDSIZE);
+    specs->memSpecs[1]->wordLen = GP_REG_CELL_WORDS;
 
+    specs->memSpecs[2]->len = 0xFF;
+    specs->memSpecs[2]->start = (1024 * OPCODE_WORDSIZE) + (32 * GP_REG_CELL_WORDS);
+    specs->memSpecs[2]->wordLen = IO_REG_CELL_WORDS;
+    
+    specs->memSpecs[3]->len = 0xFFFF;
+    specs->memSpecs[3]->start = (1024 * OPCODE_WORDSIZE) + (32 * GP_REG_CELL_WORDS) + (0xFF * IO_REG_CELL_WORDS);
+    specs->memSpecs[3]->wordLen = RAM_CELL_WORDS;
 
     char initErrbuf[200];
     device_public_context_t* ret = init(specs, initErrbuf);
@@ -725,19 +814,45 @@ uint8_t pubDeviceType()
     return DEVICE_TYPE;
 }
 
+size_t pubExtractPcounter(device_public_context_t* devContext)
+{
+    device_info_t* devInfo = (device_info_t*)devContext->deviceInfo;
+    return (size_t)(*devInfo->pc);
+
+}
+
+
+void* pubExtractPcounterPtr(device_public_context_t* devContext)
+{
+    device_info_t* devInfo = (device_info_t*)devContext->deviceInfo;
+    return (void*)(devInfo->pc);
+
+}
+uint8_t pubExtractPcounterSizeWords()
+{
+    return sizeof(prog_counter_t);
+}
+
 
 
 void reset (device_specs_t* specs, device_public_context_t* devInfo)
 {
+    // printf("reset device\n");
+    // uint8_t fuck = 0;
     for(size_t i = 0; i < specs->memSpecsCount; i++)
     {
-        const memseg_spec_t* spec = specs->memSpecs[i];
-        for(size_t j = 0; j < spec->len; j++)
+        if(i != MEMDATA_OPSIZE)
         {
-            ((uint8_t*)devInfo->deviceMem->cells[i])[j] = 0;
+            const memseg_spec_t* spec = specs->memSpecs[i];
+            for(size_t j = 0; j < spec->len; j++)
+            {
+                ((uint8_t*)devInfo->deviceMem->cells[i])[j] = 0;
+                // fuck++;
+            }
         }
     }
 
     devInfo->deviceMem->memwriteLen = 0;
     devInfo->deviceMem->memreadLen = 0;
-}
+}
+