Initial commit

inc/base_device.h

@@ -0,0 +1,21 @@
+#ifndef __BASE_DEVICE_H__
+#define __BASE_DEVICE_H__
+
+#include "hmmmm.h"
+
+typedef struct {
+    void* specs;
+    device_lib_t* lib;
+    device_public_context_t* ctx;
+    uint64_t clockCycleLimit;
+    uint64_t clockCycleCounter;
+} device_handle_t;
+
+
+device_handle_t* openBaseDeviceFromConfig(const char* configPath, char* errbuf);
+device_handle_t* openBaseDevice(conf_dev_t* devConf, char* errbuf);
+conf_dev_t* openBaseDeviceConfig(const char* configPath, char* errbuf);
+void closeBaseDevice(device_handle_t* devHandle);
+
+
+#endif // ifndef __BASE_DEVICE_H__

inc/compose_device.h

@@ -0,0 +1,41 @@
+#ifndef __COMPOSE_DEVICE_H__
+#define __COMPOSE_DEVICE_H__
+#include "base_device.h"
+
+typedef struct {
+    uint64_t limiter;
+} clock_conf_t;
+
+typedef struct {
+    char** baseAt;
+    char* baseSeg;
+    char** target;
+    uint64_t projectionShift;
+
+} projection_conf_t;
+
+typedef struct {
+
+    char** baseAt;
+    char** pointAt;
+    uint64_t addr;
+    char* seg;
+
+} intercept_conf_t;
+
+
+typedef struct {
+    clock_conf_t clockConf;
+    conf_dev_t** baseConfigs;
+    projection_conf_t** projections;
+    intercept_conf_t** intercepts;
+} compose_dev_conf_t;
+
+typedef struct {
+    device_handle_t** devHandlers;
+} compose_dev_handle_t;
+
+compose_dev_conf_t* openComposeDeviceConfig(const char* configPath, char* errbuf);
+device_handle_t** openComposeDevice(compose_dev_conf_t* conf, char* errbuf);
+
+#endif // ifndef __COMPOSE_DEVICE_H__

inc/config.h

@@ -0,0 +1,36 @@
+#ifndef __HMMMM_CONFIG_H__
+#define __HMMMM_CONFIG_H__
+#include <unistd.h>
+#include <stdint.h>
+
+
+typedef struct {
+    char* name;
+    size_t start;
+    size_t len;
+    uint8_t wordLen;
+    uint8_t isExecutable;
+} conf_mem_seg_t;
+
+typedef struct {
+    conf_mem_seg_t** memSegConfs;
+} conf_mem_t;
+
+typedef struct {
+    char** id;
+    char** clockId;
+    uint64_t clockDivider;
+    uint64_t clockMultipler;
+    conf_mem_t* memConf;
+    char* libPath;
+} conf_dev_t;
+
+
+
+void freeMemSegConf(conf_mem_seg_t* memSegConf);
+void freeMemConf(conf_mem_t* memConf);
+void freeConf(conf_dev_t* conf);
+void freeComposeId(char** id);
+uint8_t compareComposeId(char** idA, char** idB);
+
+#endif // ifndef __HMMMM_CONFIG_H__

inc/hmmmm.h

@@ -0,0 +1,33 @@
+#ifndef __HMMMMM__
+#define __HMMMMM__
+#include "libhmmmm.h"
+#include "config.h"
+
+typedef struct {
+    void* (*extractPcounterPtr)(device_public_context_t* devContext);
+
+    size_t (*extractPcounter)(device_public_context_t* devContext);
+    size_t (*extractOpcode)(device_mem_t* devMem, size_t _programCounter);
+    uint8_t (*extractPcounterSizeWords)();
+
+
+} instruction_simul_handlers_t;
+
+typedef struct {
+    uint8_t devType;
+    device_public_context_t* (*init)(void*, char* errbuf);
+    uint8_t (*makeDeviceTick)(device_public_context_t* devInfo);
+    void* extendedHandlers;
+    device_public_context_t* devContext;
+    void* _dlhandl;
+    void* (*parseSpecsFromConfig)(const conf_dev_t* devConf, char* errbuf);
+    void (*freeSpecs)(void* specs);
+    void (*freeDevMem)(device_mem_t* mem);
+    void (*fillSmartReadSpecs)(void* specs, smart_read_spec_t* smartReadSpecs, uint64_t smartReadSpecsCount);
+    void (*fillSmartWriteSpecs)(void* specs, smart_write_spec_t* smartWriteSpecs, uint64_t smartWriteSpecsCount);
+} device_lib_t;
+
+device_lib_t* loadDeviceLib(const char *libpath, char* errbuf);
+
+
+#endif // ifndef __HMMMMM__

inc/libdevice.h

@@ -0,0 +1,37 @@
+#ifndef __LIBDEVICE_H__
+#define __LIBDEVICE_H__
+
+#include <stdint.h>
+#include "libmem.h"
+
+#define SMART_ADDR_TYPE_GLOBAL 1
+#define SMART_ADDR_TYPE_SEGMENTED 2
+typedef struct 
+{
+    uint64_t addr;
+    uint8_t segno;
+    uint64_t localAddr;
+    uint8_t addrType;
+    mem_h_read_func* handler;
+    uint64_t ident;
+} smart_read_spec_t;
+
+typedef struct 
+{
+    uint64_t addr;
+    uint8_t segno;
+    uint64_t localAddr;
+    uint8_t addrType;
+    mem_h_write_func handler;
+    uint64_t ident;
+} smart_write_spec_t;
+
+typedef struct {
+    device_mem_t* deviceMem;
+    void* deviceInfo;
+} device_public_context_t;
+
+
+
+#endif // ifndef __LIBDEVICE_H__
+

inc/libhmmmm.h

@@ -0,0 +1,14 @@
+#ifndef __LIB_HMMMMM__
+#define __LIB_HMMMMM__
+
+#include "libmem.h"
+#include "libdevice.h"
+
+#define EXTENDED_DEVICE_TYPE_DUMMY 0
+#define EXTENDED_DEVICE_TYPE_INSTR_SIMUL 1
+
+
+
+
+
+#endif // ifndef __LIB_HMMMMM__

inc/libmem.h

@@ -0,0 +1,52 @@
+#ifndef __LIBMEM_H__
+#define __LIBMEM_H__
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#define GET_BIT(n, b) ((n >> b) & 1)
+
+// Internal mem handlers
+typedef void* (*mem_h_read_func)(uint64_t ident, uint64_t addr, void* rawCells);
+typedef void (*mem_h_write_func)(uint64_t ident, uint64_t addr, void* rawCells, void* data);
+
+typedef struct {
+    mem_h_read_func func;
+    uint64_t ident;
+} mem_h_read_handler;
+typedef struct {
+    mem_h_write_func func;
+    uint64_t ident;
+} mem_h_write_handler;
+
+typedef struct 
+{
+    void* rawCells;
+    void** cells;
+    uint64_t smartAddrReadMask;
+    uint64_t smartAddrWriteMask;
+    mem_h_read_handler* smartAddrReadHandlers;
+    mem_h_write_handler* smartAddrWriteHandlers;
+    char** memsegNames;
+    uint64_t* memsegShifts;
+    uint64_t* memreadCellAddrs;
+    uint64_t* memwriteCellAddrs;
+    uint8_t memreadLen;
+    uint8_t memwriteLen;
+} device_mem_t;
+
+
+typedef struct 
+{
+    uint64_t start;
+    uint64_t len;
+    uint8_t wordLen;
+    char* name;
+} memseg_spec_t;
+
+
+// External handlers
+typedef void* (*ext_h_read_func)(uint64_t addr, void* rawCells, void* devContext);
+typedef void (*ext_h_write_func)(uint64_t addr, void* rawCells, void* data, void* devContext);
+
+#endif // ifndef __LIBMEM_H__

inc/my_mutex.h

@@ -0,0 +1,22 @@
+#ifndef __MY_MUTEX_H__
+#define __MY_MUTEX_H__
+#include <pthread.h>
+
+/**
+ * Макрос для pthread_mutex_t
+ * Использовать так:
+ * with_lock(&mtx)
+ * {
+ *      secured_code();
+ * }
+ */
+
+#define __MY_MUTEX__CONCAT(x, y) x##y
+#define __MY_MUTEX__UNIQUE_NAME(base) __MY_MUTEX__CONCAT(base, __LINE__)
+
+#define with_lock(mutex) \
+    for (int __MY_MUTEX__UNIQUE_NAME(_once) = (pthread_mutex_lock(mutex), 1); \
+         __MY_MUTEX__UNIQUE_NAME(_once); \
+         pthread_mutex_unlock(mutex), __MY_MUTEX__UNIQUE_NAME(_once) = 0)
+
+#endif //ifndef __MY_MUTEX_H__