Initial commit

.gitignore

@@ -1,6 +1,10 @@
-.vscode
+AVRe_build
-.ccls-cache
+AVRrc_build
-out
+AVRxm_build
-compile_commands.json
+AVRxt_build
-compile_commands.json
 .cache
+.ccls-cache
+compile_commands.json
+out
+.pytest_cache
+.vscode

Makefile

@@ -19,17 +19,17 @@ CC=gcc
 OBJDUMP=objdump
 LIBS=
 STANDART=c23
+
 OPTIMIZE=-Og
 TARGET=device
 ifeq ($(ARCH),)
 ARCH := "template"
 endif
-
+START_AT := $(shell date)
-
 DEFINES=-DOPCODE_WORDSIZE=2 -DMEM_CELL_WORDS=1 -DPC_WORDSIZE=3 -DGP_REG_CELL_WORDS=1 -DIO_REG_CELL_WORDS=1 -DARCH=$(ARCH)
-
+C_SOURCES=$(wildcard $(SRC_DIR)/*.c $(SRC_DIR)/instructions/*.c)
-C_SOURCES=$(wildcard $(SRC_DIR)/*.c)
 MANIFEST_C_SOURCES=$(wildcard $(MANIFEST_SRC_DIR)/*.c)
+
 C_HEADERS=$(wildcard $(INC_DIR)/*.h)
 
 C_INCLUDES=-I$(INC_DIR)/ -I$(HMMMM_LIB_DIR)
@@ -42,16 +42,18 @@ CFLAGS=$(C_DEFS) -g $(C_INCLUDES) $(DEFINES) $(OPTIMIZE) --std=$(STANDART) $(PED
 LFLAGS=$(OPTIMIZE) -g $(PEDANTIC_FLAGS) $(DEFINES) -flto -fuse-linker-plugin $(LSECTIONS) -lm $(LIBS) -fPIC -shared
 MANIFEST_LFLAGS=$(OPTIMIZE) -g $(PEDANTIC_FLAGS) $(DEFINES) -flto -fuse-linker-plugin $(LSECTIONS) -lm $(LIBS) -fPIC
 
+OBJECTS := $(addprefix $(BUILD_DIR)/,$(patsubst src/%.c,$(PREFIX)%.o,$(C_SOURCES)))
 
-
-OBJECTS = $(addprefix $(BUILD_DIR)/,$(notdir $(C_SOURCES:.c=.o)))
 MANIFEST_TARGETS = $(addprefix $(MANIFEST_BUILD_DIR)/,$(notdir $(MANIFEST_C_SOURCES:.c=.elf)))
+
+BUILDPATHS := $(dir $(OBJECTS))
+
 vpath %.c $(sort $(dir $(C_SOURCES)))
 vpath %.h $(sort $(dir $(C_HEADERS)))
 
 rebuild: clean | build
 
-all: build manifest
+all: AVRe AVRrc AVRxm AVRxt
 
 build: date Dir $(C_HEADERS) target
 
@@ -63,9 +65,10 @@ $(BUILD_DIR)/%.o: %.c Makefile | $(BUILD_DIR)
 target: date $(BUILD_DIR)/$(TARGET).so
 
 $(BUILD_DIR)/$(TARGET).so: $(OBJECTS)
-	@echo -e '\033[1;32mELF ('$(ARCH)')\t'$(OBJECTS)'\n\t\t\t->\t'$@'\033[0m'
+	@echo -e '\033[1;32mLD ('$(ARCH)')\t'$(OBJECTS)'\n\t\t\t->\t'$@'\033[0m'
 	@$(CC) $(LFLAGS) $(OBJECTS) -o $(BUILD_DIR)/$(TARGET).so
 
+
 manifest: $(MANIFEST_BUILD_DIR)/MANIFEST.json
 
 $(MANIFEST_BUILD_DIR)/MANIFEST.json: $(C_HEADERS) $(MANIFEST_TARGETS)
@@ -90,8 +93,34 @@ $(BUILD_DIR):
 $(MANIFEST_BUILD_DIR):
 	@mkdir -p $(MANIFEST_BUILD_DIR)
 
+
+
+AVRe: AVRe_build/AVRe.so
+AVRrc: AVRrc_build/AVRrc.so
+AVRxm: AVRxm_build/AVRxm.so
+AVRxt: AVRxt_build/AVRxt.so
+
+
+
+AVRe_build/AVRe.so:
+	@echo -e '\033[1;32mMK (AVRe)\033[0m'
+	@$(MAKE) --no-print-directory rebuild ARCH=AVRe BUILD_DIR=AVRe_build
+
+AVRrc_build/AVRrc.so:
+	@echo -e '\033[1;32mMK (AVRrc)\033[0m'
+	@$(MAKE) --no-print-directory rebuild ARCH=AVRrc BUILD_DIR=AVRrc_build
+
+AVRxm_build/AVRxm.so:
+	@echo -e '\033[1;32mMK (AVRxm)\033[0m'
+	@$(MAKE) --no-print-directory rebuild ARCH=AVRxm BUILD_DIR=AVRxm_build
+
+AVRxt_build/AVRxt.so:
+	@echo -e '\033[1;32mMK (AVRxt)\033[0m'
+	@$(MAKE) --no-print-directory rebuild ARCH=AVRxt BUILD_DIR=AVRxt_build
+
 BuildDir:
 	@mkdir -p $(BUILD_DIR)
+	@mkdir -p $(BUILDPATHS)
 
 SrcDir:
 	@mkdir -p $(SRC_DIR)
@@ -104,11 +133,11 @@ Dir: BuildDir SrcDir IncDir
 .PHONY: clean
 clean:
 	@rm -rf $(BUILD_DIR)/*
+	@rm -rf AVRe_build AVRrc_build AVRxm_build AVRxt_build
 	@echo -e '\033[0;31mCleaned\033[0m'
 
 .NOTPARALLEL: date target rebuild
 date:
-	@echo -e '\033[1;32m'"Starting build at " | tr -d '\n'
+	@echo -e '\033[1;32m'"Starting build at "$(START_AT)'\033[0m'
-	@date
+
-	@echo -e '\033[0m'
 

inc/addrs.h

@@ -1,7 +1,22 @@
 #ifndef __ADDRS_H__
 #define __ADDRS_H__
+#include "mem_seg.h"
+
+#define IOREG_SREG_ADDR  0x5F
+#define IOREG_SPH_ADDR   0x5E
+#define IOREG_SPL_ADDR   0x5D
+#define IOREG_EIND_ADDR  0x5C
+#define IOREG_RAMPZ_ADDR 0x5B
+
+
+#define GPREG_ZH_ADDR 31
+#define GPREG_ZL_ADDR 30
+
+#define GPREG_YH_ADDR 29
+#define GPREG_YL_ADDR 28
+
+#define GPREG_XH_ADDR 27
+#define GPREG_XL_ADDR 26
 
-#define MEMDATA_IO_REGS   0
-#define MEMDATA_EXTSTATE  1
 
 #endif // ifndef __ADDRS_H__

inc/device.h

@@ -49,7 +49,6 @@ size_t pubExtractPcounter(device_public_context_t* devContext);
 size_t pubExtractOpcode(device_mem_t* devMem, size_t _programCounter);
 void* pubExtractPcounterPtr(device_public_context_t* devContext);
 uint8_t pubExtractPcounterSizeWords();
-
 device_specs_t* parseSpecsFromConfig(const conf_dev_t* devConf, char* errbuf);
 void fillSmartReadSpecs(device_specs_t* specs, smart_read_spec_t* smartReadSpecs, uint64_t smartReadSpecsCount);
 void fillSmartWriteSpecs(device_specs_t* specs, smart_write_spec_t* smartWriteSpecs, uint64_t smartWriteSpecsCount);

inc/generated.h

@@ -0,0 +1,17 @@
+#include "instr.h"
+#include "mem.h"
+#include <stdio.h>
+#include "addrs.h"
+
+#if ARCH == AVRe
+#include "generated_AVRe.h"
+#endif
+#if ARCH == AVRxm
+#include "generated_AVRxm.h"
+#endif
+#if ARCH == AVRxt
+#include "generated_AVRxt.h"
+#endif
+#if ARCH == AVRrc
+#include "generated_AVRrc.h"
+#endif

inc/generated_AVRe.h

@@ -0,0 +1,200 @@
+#ifndef __GENERATED_INSTR_H__
+#define __GENERATED_INSTR_H__
+#include "instr.h"
+#include "mem.h"
+#include <stdio.h>
+#include "addrs.h"
+
+uint8_t _adc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _add        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _adiw       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _and        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _andi       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _asr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bclr       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bld        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _brbc       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _brbs       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _break      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bset       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bst        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _call       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cbi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _com        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cp         (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cpc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cpi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cpse       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _dec        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _des        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _eicall     (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _eijmp      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _elpm1      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _elpm2      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _elpm3      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _eor        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _fmul       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _fmuls      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _fmulsu     (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _icall      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ijmp       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _in         (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _inc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _jmp        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lac        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _las        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lat        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld1        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld2        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld3        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd2    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd3    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd4    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd_12  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd_13  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd_14  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ldi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lds        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lds_avrrc  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lpm1       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lpm2       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lpm3       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lsr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _mov        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _movw       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _mul        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _muls       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _mulsu      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _neg        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _nop        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _or         (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _out        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _pop        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _push       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _rcall      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ret        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _reti       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _rjmp       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ror        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbci       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbic       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbis       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbiw       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbrc       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbrs       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sleep      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _spm        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st1        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st2        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st3        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std2    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std3    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std4    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std_12  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std_13  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std_14  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sts        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sts_avrrc  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sub        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _subi       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _swap       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _wdr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _xch        (prog_counter_t* pcounter, device_mem_t* devMem);
+
+
+#define HANDLER_REGISTERS {\
+	{&_adc,        0b0001110000000000,	0b0000001111111111,	2}, \
+	{&_add,        0b0000110000000000,	0b0000001111111111,	2}, \
+	{&_adiw,       0b1001011000000000,	0b0000000011111111,	2}, \
+	{&_and,        0b0010000000000000,	0b0000001111111111,	2}, \
+	{&_andi,       0b0111000000000000,	0b0000111111111111,	2}, \
+	{&_asr,        0b1001010000000101,	0b0000000111110000,	2}, \
+	{&_bclr,       0b1001010010001000,	0b0000000001110000,	2}, \
+	{&_bld,        0b1111100000000000,	0b0000000111110111,	2}, \
+	{&_brbc,       0b1111010000000000,	0b0000001111111111,	2}, \
+	{&_brbs,       0b1111000000000000,	0b0000001111111111,	2}, \
+	{&_break,      0b1001010110011000,	0b0000000000000000,	2}, \
+	{&_bset,       0b1001010000001000,	0b0000000001110000,	2}, \
+	{&_bst,        0b1111101000000000,	0b0000000111110111,	2}, \
+	{&_call,       0b1001010000001110,	0b0000000111110001,	4}, \
+	{&_cbi,        0b1001100000000000,	0b0000000011111111,	2}, \
+	{&_com,        0b1001010000000000,	0b0000000111110000,	2}, \
+	{&_cp,         0b0001010000000000,	0b0000001111111111,	2}, \
+	{&_cpc,        0b0000010000000000,	0b0000001111111111,	2}, \
+	{&_cpi,        0b0011000000000000,	0b0000111111111111,	2}, \
+	{&_cpse,       0b0001000000000000,	0b0000001111111111,	2}, \
+	{&_dec,        0b1001010000001010,	0b0000000111110000,	2}, \
+	{&_eicall,     0b1001010100011001,	0b0000000000000000,	2}, \
+	{&_eijmp,      0b1001010000011001,	0b0000000000000000,	2}, \
+	{&_elpm1,      0b1001010111011000,	0b0000000000000000,	2}, \
+	{&_elpm2,      0b1001000000000110,	0b0000000111110000,	2}, \
+	{&_elpm3,      0b1001000000000111,	0b0000000111110000,	2}, \
+	{&_eor,        0b0010010000000000,	0b0000001111111111,	2}, \
+	{&_fmul,       0b0000001100001000,	0b0000000001110111,	2}, \
+	{&_fmuls,      0b0000001110000000,	0b0000000001110111,	2}, \
+	{&_fmulsu,     0b0000001110001000,	0b0000000001110111,	2}, \
+	{&_icall,      0b1001010100001001,	0b0000000000000000,	2}, \
+	{&_ijmp,       0b1001010000001001,	0b0000000000000000,	2}, \
+	{&_in,         0b1011000000000000,	0b0000011111111111,	2}, \
+	{&_inc,        0b1001010000000011,	0b0000000111110000,	2}, \
+	{&_jmp,        0b1001010000001100,	0b0000000111110001,	4}, \
+	{&_ld1,        0b1001000000001100,	0b0000000111110000,	2}, \
+	{&_ld2,        0b1001000000001101,	0b0000000111110000,	2}, \
+	{&_ld3,        0b1001000000001110,	0b0000000111110000,	2}, \
+	{&_ld_ldd2,    0b1001000000001001,	0b0000000111110000,	2}, \
+	{&_ld_ldd3,    0b1001000000001010,	0b0000000111110000,	2}, \
+	{&_ld_ldd4,    0b1000000000001000,	0b0010110111110111,	2}, \
+	{&_ld_ldd_12,  0b1001000000000001,	0b0000000111110000,	2}, \
+	{&_ld_ldd_13,  0b1001000000000010,	0b0000000111110000,	2}, \
+	{&_ld_ldd_14,  0b1000000000000000,	0b0010110111110111,	2}, \
+	{&_ldi,        0b1110000000000000,	0b0000111111111111,	2}, \
+	{&_lds,        0b1001000000000000,	0b0000000111110000,	4}, \
+	{&_lpm1,       0b1001010111001000,	0b0000000000000000,	2}, \
+	{&_lpm2,       0b1001000000000100,	0b0000000111110000,	2}, \
+	{&_lpm3,       0b1001000000000101,	0b0000000111110000,	2}, \
+	{&_lsr,        0b1001010000000110,	0b0000000111110000,	2}, \
+	{&_mov,        0b0010110000000000,	0b0000001111111111,	2}, \
+	{&_movw,       0b0000000100000000,	0b0000000011111111,	2}, \
+	{&_mul,        0b1001110000000000,	0b0000001111111111,	2}, \
+	{&_muls,       0b0000001000000000,	0b0000000011111111,	2}, \
+	{&_mulsu,      0b0000001100000000,	0b0000000001110111,	2}, \
+	{&_neg,        0b1001010000000001,	0b0000000111110000,	2}, \
+	{&_nop,        0b0000000000000000,	0b0000000000000000,	2}, \
+	{&_or,         0b0010100000000000,	0b0000001111111111,	2}, \
+	{&_out,        0b1011100000000000,	0b0000011111111111,	2}, \
+	{&_pop,        0b1001000000001111,	0b0000000111110000,	2}, \
+	{&_push,       0b1001001000001111,	0b0000000111110000,	2}, \
+	{&_rcall,      0b1101000000000000,	0b0000111111111111,	2}, \
+	{&_ret,        0b1001010100001000,	0b0000000000000000,	2}, \
+	{&_reti,       0b1001010100011000,	0b0000000000000000,	2}, \
+	{&_rjmp,       0b1100000000000000,	0b0000111111111111,	2}, \
+	{&_ror,        0b1001010000000111,	0b0000000111110000,	2}, \
+	{&_sbc,        0b0000100000000000,	0b0000001111111111,	2}, \
+	{&_sbci,       0b0100000000000000,	0b0000111111111111,	2}, \
+	{&_sbi,        0b1001101000000000,	0b0000000011111111,	2}, \
+	{&_sbic,       0b1001100100000000,	0b0000000011111111,	2}, \
+	{&_sbis,       0b1001101100000000,	0b0000000011111111,	2}, \
+	{&_sbiw,       0b1001011100000000,	0b0000000011111111,	2}, \
+	{&_sbr,        0b0110000000000000,	0b0000111111111111,	2}, \
+	{&_sbrc,       0b1111110000000000,	0b0000000111110111,	2}, \
+	{&_sbrs,       0b1111111000000000,	0b0000000111110111,	2}, \
+	{&_sleep,      0b1001010110001000,	0b0000000000000000,	2}, \
+	{&_spm,        0b1001010111101000,	0b0000000000000000,	2}, \
+	{&_st1,        0b1001001000001100,	0b0000000111110000,	2}, \
+	{&_st2,        0b1001001000001101,	0b0000000111110000,	2}, \
+	{&_st3,        0b1001001000001110,	0b0000000111110000,	2}, \
+	{&_st_std2,    0b1001001000001001,	0b0000000111110000,	2}, \
+	{&_st_std3,    0b1001001000001010,	0b0000000111110000,	2}, \
+	{&_st_std4,    0b1000001000001000,	0b0010110111110111,	2}, \
+	{&_st_std_12,  0b1001001000000001,	0b0000000111110000,	2}, \
+	{&_st_std_13,  0b1001001000000010,	0b0000000111110000,	2}, \
+	{&_st_std_14,  0b1000001000000000,	0b0010110111110111,	2}, \
+	{&_sts,        0b1001001000000000,	0b0000000111110000,	4}, \
+	{&_sub,        0b0001100000000000,	0b0000001111111111,	2}, \
+	{&_subi,       0b0101000000000000,	0b0000111111111111,	2}, \
+	{&_swap,       0b1001010000000010,	0b0000000111110000,	2}, \
+	{&_wdr,        0b1001010110101000,	0b0000000000000000,	2}	}
+#endif // ifndef __GENERATED_INSTR_H__

inc/generated_AVRrc.h

@@ -0,0 +1,176 @@
+#ifndef __GENERATED_INSTR_H__
+#define __GENERATED_INSTR_H__
+#include "instr.h"
+#include "mem.h"
+#include <stdio.h>
+#include "addrs.h"
+
+uint8_t _adc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _add        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _adiw       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _and        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _andi       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _asr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bclr       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bld        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _brbc       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _brbs       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _break      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bset       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bst        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _call       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cbi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _com        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cp         (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cpc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cpi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cpse       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _dec        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _des        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _eicall     (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _eijmp      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _elpm1      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _elpm2      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _elpm3      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _eor        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _fmul       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _fmuls      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _fmulsu     (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _icall      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ijmp       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _in         (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _inc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _jmp        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lac        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _las        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lat        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld1        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld2        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld3        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd2    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd3    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd4    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd_12  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd_13  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd_14  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ldi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lds        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lds_avrrc  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lpm1       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lpm2       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lpm3       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lsr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _mov        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _movw       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _mul        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _muls       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _mulsu      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _neg        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _nop        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _or         (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _out        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _pop        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _push       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _rcall      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ret        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _reti       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _rjmp       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ror        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbci       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbic       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbis       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbiw       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbrc       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbrs       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sleep      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _spm        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st1        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st2        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st3        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std2    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std3    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std4    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std_12  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std_13  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std_14  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sts        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sts_avrrc  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sub        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _subi       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _swap       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _wdr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _xch        (prog_counter_t* pcounter, device_mem_t* devMem);
+
+
+#define HANDLER_REGISTERS {\
+	{&_adc,        0b0001110000000000,	0b0000001111111111,	2}, \
+	{&_add,        0b0000110000000000,	0b0000001111111111,	2}, \
+	{&_and,        0b0010000000000000,	0b0000001111111111,	2}, \
+	{&_andi,       0b0111000000000000,	0b0000111111111111,	2}, \
+	{&_asr,        0b1001010000000101,	0b0000000111110000,	2}, \
+	{&_bclr,       0b1001010010001000,	0b0000000001110000,	2}, \
+	{&_bld,        0b1111100000000000,	0b0000000111110111,	2}, \
+	{&_brbc,       0b1111010000000000,	0b0000001111111111,	2}, \
+	{&_brbs,       0b1111000000000000,	0b0000001111111111,	2}, \
+	{&_break,      0b1001010110011000,	0b0000000000000000,	2}, \
+	{&_bset,       0b1001010000001000,	0b0000000001110000,	2}, \
+	{&_bst,        0b1111101000000000,	0b0000000111110111,	2}, \
+	{&_cbi,        0b1001100000000000,	0b0000000011111111,	2}, \
+	{&_com,        0b1001010000000000,	0b0000000111110000,	2}, \
+	{&_cp,         0b0001010000000000,	0b0000001111111111,	2}, \
+	{&_cpc,        0b0000010000000000,	0b0000001111111111,	2}, \
+	{&_cpi,        0b0011000000000000,	0b0000111111111111,	2}, \
+	{&_cpse,       0b0001000000000000,	0b0000001111111111,	2}, \
+	{&_dec,        0b1001010000001010,	0b0000000111110000,	2}, \
+	{&_eor,        0b0010010000000000,	0b0000001111111111,	2}, \
+	{&_icall,      0b1001010100001001,	0b0000000000000000,	2}, \
+	{&_ijmp,       0b1001010000001001,	0b0000000000000000,	2}, \
+	{&_in,         0b1011000000000000,	0b0000011111111111,	2}, \
+	{&_inc,        0b1001010000000011,	0b0000000111110000,	2}, \
+	{&_ld1,        0b1001000000001100,	0b0000000111110000,	2}, \
+	{&_ld2,        0b1001000000001101,	0b0000000111110000,	2}, \
+	{&_ld3,        0b1001000000001110,	0b0000000111110000,	2}, \
+	{&_ld_ldd2,    0b1001000000001001,	0b0000000111110000,	2}, \
+	{&_ld_ldd3,    0b1001000000001010,	0b0000000111110000,	2}, \
+	{&_ld_ldd_12,  0b1001000000000001,	0b0000000111110000,	2}, \
+	{&_ld_ldd_13,  0b1001000000000010,	0b0000000111110000,	2}, \
+	{&_ldi,        0b1110000000000000,	0b0000111111111111,	2}, \
+	{&_lds_avrrc,  0b1010000000000000,	0b0000011111111111,	2}, \
+	{&_lsr,        0b1001010000000110,	0b0000000111110000,	2}, \
+	{&_mov,        0b0010110000000000,	0b0000001111111111,	2}, \
+	{&_neg,        0b1001010000000001,	0b0000000111110000,	2}, \
+	{&_nop,        0b0000000000000000,	0b0000000000000000,	2}, \
+	{&_or,         0b0010100000000000,	0b0000001111111111,	2}, \
+	{&_out,        0b1011100000000000,	0b0000011111111111,	2}, \
+	{&_pop,        0b1001000000001111,	0b0000000111110000,	2}, \
+	{&_push,       0b1001001000001111,	0b0000000111110000,	2}, \
+	{&_rcall,      0b1101000000000000,	0b0000111111111111,	2}, \
+	{&_ret,        0b1001010100001000,	0b0000000000000000,	2}, \
+	{&_reti,       0b1001010100011000,	0b0000000000000000,	2}, \
+	{&_rjmp,       0b1100000000000000,	0b0000111111111111,	2}, \
+	{&_ror,        0b1001010000000111,	0b0000000111110000,	2}, \
+	{&_sbc,        0b0000100000000000,	0b0000001111111111,	2}, \
+	{&_sbci,       0b0100000000000000,	0b0000111111111111,	2}, \
+	{&_sbi,        0b1001101000000000,	0b0000000011111111,	2}, \
+	{&_sbic,       0b1001100100000000,	0b0000000011111111,	2}, \
+	{&_sbis,       0b1001101100000000,	0b0000000011111111,	2}, \
+	{&_sbr,        0b0110000000000000,	0b0000111111111111,	2}, \
+	{&_sbrc,       0b1111110000000000,	0b0000000111110111,	2}, \
+	{&_sbrs,       0b1111111000000000,	0b0000000111110111,	2}, \
+	{&_sleep,      0b1001010110001000,	0b0000000000000000,	2}, \
+	{&_st1,        0b1001001000001100,	0b0000000111110000,	2}, \
+	{&_st2,        0b1001001000001101,	0b0000000111110000,	2}, \
+	{&_st3,        0b1001001000001110,	0b0000000111110000,	2}, \
+	{&_st_std2,    0b1001001000001001,	0b0000000111110000,	2}, \
+	{&_st_std3,    0b1001001000001010,	0b0000000111110000,	2}, \
+	{&_st_std_12,  0b1001001000000001,	0b0000000111110000,	2}, \
+	{&_st_std_13,  0b1001001000000010,	0b0000000111110000,	2}, \
+	{&_sts_avrrc,  0b1010100000000000,	0b0000011111111111,	2}, \
+	{&_sub,        0b0001100000000000,	0b0000001111111111,	2}, \
+	{&_subi,       0b0101000000000000,	0b0000111111111111,	2}, \
+	{&_swap,       0b1001010000000010,	0b0000000111110000,	2}, \
+	{&_wdr,        0b1001010110101000,	0b0000000000000000,	2}	}
+#endif // ifndef __GENERATED_INSTR_H__

inc/generated_AVRxm.h

@@ -0,0 +1,204 @@
+#ifndef __GENERATED_INSTR_H__
+#define __GENERATED_INSTR_H__
+#include "instr.h"
+#include "mem.h"
+#include <stdio.h>
+#include "addrs.h"
+
+uint8_t _adc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _add        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _adiw       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _and        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _andi       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _asr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bclr       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bld        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _brbc       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _brbs       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _break      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bset       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bst        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _call       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cbi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _com        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cp         (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cpc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cpi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cpse       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _dec        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _des        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _eicall     (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _eijmp      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _elpm1      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _elpm2      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _elpm3      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _eor        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _fmul       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _fmuls      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _fmulsu     (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _icall      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ijmp       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _in         (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _inc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _jmp        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lac        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _las        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lat        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld1        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld2        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld3        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd2    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd3    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd4    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd_12  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd_13  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd_14  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ldi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lds        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lds_avrrc  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lpm1       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lpm2       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lpm3       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lsr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _mov        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _movw       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _mul        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _muls       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _mulsu      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _neg        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _nop        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _or         (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _out        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _pop        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _push       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _rcall      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ret        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _reti       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _rjmp       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ror        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbci       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbic       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbis       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbiw       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbrc       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbrs       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sleep      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _spm        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st1        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st2        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st3        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std2    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std3    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std4    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std_12  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std_13  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std_14  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sts        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sts_avrrc  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sub        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _subi       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _swap       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _wdr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _xch        (prog_counter_t* pcounter, device_mem_t* devMem);
+
+
+#define HANDLER_REGISTERS {\
+	{&_adc,        0b0001110000000000,	0b0000001111111111,	2}, \
+	{&_add,        0b0000110000000000,	0b0000001111111111,	2}, \
+	{&_adiw,       0b1001011000000000,	0b0000000011111111,	2}, \
+	{&_and,        0b0010000000000000,	0b0000001111111111,	2}, \
+	{&_andi,       0b0111000000000000,	0b0000111111111111,	2}, \
+	{&_asr,        0b1001010000000101,	0b0000000111110000,	2}, \
+	{&_bclr,       0b1001010010001000,	0b0000000001110000,	2}, \
+	{&_bld,        0b1111100000000000,	0b0000000111110111,	2}, \
+	{&_brbc,       0b1111010000000000,	0b0000001111111111,	2}, \
+	{&_brbs,       0b1111000000000000,	0b0000001111111111,	2}, \
+	{&_break,      0b1001010110011000,	0b0000000000000000,	2}, \
+	{&_bset,       0b1001010000001000,	0b0000000001110000,	2}, \
+	{&_bst,        0b1111101000000000,	0b0000000111110111,	2}, \
+	{&_call,       0b1001010000001110,	0b0000000111110001,	4}, \
+	{&_cbi,        0b1001100000000000,	0b0000000011111111,	2}, \
+	{&_com,        0b1001010000000000,	0b0000000111110000,	2}, \
+	{&_cp,         0b0001010000000000,	0b0000001111111111,	2}, \
+	{&_cpc,        0b0000010000000000,	0b0000001111111111,	2}, \
+	{&_cpi,        0b0011000000000000,	0b0000111111111111,	2}, \
+	{&_cpse,       0b0001000000000000,	0b0000001111111111,	2}, \
+	{&_dec,        0b1001010000001010,	0b0000000111110000,	2}, \
+	{&_des,        0b1001010000001011,	0b0000000011110000,	2}, \
+	{&_eicall,     0b1001010100011001,	0b0000000000000000,	2}, \
+	{&_eijmp,      0b1001010000011001,	0b0000000000000000,	2}, \
+	{&_elpm1,      0b1001010111011000,	0b0000000000000000,	2}, \
+	{&_elpm2,      0b1001000000000110,	0b0000000111110000,	2}, \
+	{&_elpm3,      0b1001000000000111,	0b0000000111110000,	2}, \
+	{&_eor,        0b0010010000000000,	0b0000001111111111,	2}, \
+	{&_fmul,       0b0000001100001000,	0b0000000001110111,	2}, \
+	{&_fmuls,      0b0000001110000000,	0b0000000001110111,	2}, \
+	{&_fmulsu,     0b0000001110001000,	0b0000000001110111,	2}, \
+	{&_icall,      0b1001010100001001,	0b0000000000000000,	2}, \
+	{&_ijmp,       0b1001010000001001,	0b0000000000000000,	2}, \
+	{&_in,         0b1011000000000000,	0b0000011111111111,	2}, \
+	{&_inc,        0b1001010000000011,	0b0000000111110000,	2}, \
+	{&_jmp,        0b1001010000001100,	0b0000000111110001,	4}, \
+	{&_lac,        0b1001001000000110,	0b0000000111110000,	2}, \
+	{&_las,        0b1001001000000101,	0b0000000111110000,	2}, \
+	{&_lat,        0b1001001000000111,	0b0000000111110000,	2}, \
+	{&_ld1,        0b1001000000001100,	0b0000000111110000,	2}, \
+	{&_ld2,        0b1001000000001101,	0b0000000111110000,	2}, \
+	{&_ld3,        0b1001000000001110,	0b0000000111110000,	2}, \
+	{&_ld_ldd2,    0b1001000000001001,	0b0000000111110000,	2}, \
+	{&_ld_ldd3,    0b1001000000001010,	0b0000000111110000,	2}, \
+	{&_ld_ldd4,    0b1000000000001000,	0b0010110111110111,	2}, \
+	{&_ld_ldd_12,  0b1001000000000001,	0b0000000111110000,	2}, \
+	{&_ld_ldd_13,  0b1001000000000010,	0b0000000111110000,	2}, \
+	{&_ld_ldd_14,  0b1000000000000000,	0b0010110111110111,	2}, \
+	{&_ldi,        0b1110000000000000,	0b0000111111111111,	2}, \
+	{&_lds,        0b1001000000000000,	0b0000000111110000,	4}, \
+	{&_lpm1,       0b1001010111001000,	0b0000000000000000,	2}, \
+	{&_lpm2,       0b1001000000000100,	0b0000000111110000,	2}, \
+	{&_lpm3,       0b1001000000000101,	0b0000000111110000,	2}, \
+	{&_lsr,        0b1001010000000110,	0b0000000111110000,	2}, \
+	{&_mov,        0b0010110000000000,	0b0000001111111111,	2}, \
+	{&_movw,       0b0000000100000000,	0b0000000011111111,	2}, \
+	{&_mul,        0b1001110000000000,	0b0000001111111111,	2}, \
+	{&_muls,       0b0000001000000000,	0b0000000011111111,	2}, \
+	{&_mulsu,      0b0000001100000000,	0b0000000001110111,	2}, \
+	{&_neg,        0b1001010000000001,	0b0000000111110000,	2}, \
+	{&_nop,        0b0000000000000000,	0b0000000000000000,	2}, \
+	{&_or,         0b0010100000000000,	0b0000001111111111,	2}, \
+	{&_out,        0b1011100000000000,	0b0000011111111111,	2}, \
+	{&_pop,        0b1001000000001111,	0b0000000111110000,	2}, \
+	{&_push,       0b1001001000001111,	0b0000000111110000,	2}, \
+	{&_rcall,      0b1101000000000000,	0b0000111111111111,	2}, \
+	{&_ret,        0b1001010100001000,	0b0000000000000000,	2}, \
+	{&_reti,       0b1001010100011000,	0b0000000000000000,	2}, \
+	{&_rjmp,       0b1100000000000000,	0b0000111111111111,	2}, \
+	{&_ror,        0b1001010000000111,	0b0000000111110000,	2}, \
+	{&_sbc,        0b0000100000000000,	0b0000001111111111,	2}, \
+	{&_sbci,       0b0100000000000000,	0b0000111111111111,	2}, \
+	{&_sbi,        0b1001101000000000,	0b0000000011111111,	2}, \
+	{&_sbic,       0b1001100100000000,	0b0000000011111111,	2}, \
+	{&_sbis,       0b1001101100000000,	0b0000000011111111,	2}, \
+	{&_sbiw,       0b1001011100000000,	0b0000000011111111,	2}, \
+	{&_sbr,        0b0110000000000000,	0b0000111111111111,	2}, \
+	{&_sbrc,       0b1111110000000000,	0b0000000111110111,	2}, \
+	{&_sbrs,       0b1111111000000000,	0b0000000111110111,	2}, \
+	{&_sleep,      0b1001010110001000,	0b0000000000000000,	2}, \
+	{&_st1,        0b1001001000001100,	0b0000000111110000,	2}, \
+	{&_st2,        0b1001001000001101,	0b0000000111110000,	2}, \
+	{&_st3,        0b1001001000001110,	0b0000000111110000,	2}, \
+	{&_st_std2,    0b1001001000001001,	0b0000000111110000,	2}, \
+	{&_st_std3,    0b1001001000001010,	0b0000000111110000,	2}, \
+	{&_st_std4,    0b1000001000001000,	0b0010110111110111,	2}, \
+	{&_st_std_12,  0b1001001000000001,	0b0000000111110000,	2}, \
+	{&_st_std_13,  0b1001001000000010,	0b0000000111110000,	2}, \
+	{&_st_std_14,  0b1000001000000000,	0b0010110111110111,	2}, \
+	{&_sts,        0b1001001000000000,	0b0000000111110000,	4}, \
+	{&_sub,        0b0001100000000000,	0b0000001111111111,	2}, \
+	{&_subi,       0b0101000000000000,	0b0000111111111111,	2}, \
+	{&_swap,       0b1001010000000010,	0b0000000111110000,	2}, \
+	{&_wdr,        0b1001010110101000,	0b0000000000000000,	2}, \
+	{&_xch,        0b1001001000000100,	0b0000000111110000,	2}	}
+#endif // ifndef __GENERATED_INSTR_H__

inc/generated_AVRxt.h

@@ -0,0 +1,199 @@
+#ifndef __GENERATED_INSTR_H__
+#define __GENERATED_INSTR_H__
+#include "instr.h"
+#include "mem.h"
+#include <stdio.h>
+#include "addrs.h"
+
+uint8_t _adc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _add        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _adiw       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _and        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _andi       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _asr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bclr       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bld        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _brbc       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _brbs       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _break      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bset       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _bst        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _call       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cbi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _com        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cp         (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cpc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cpi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _cpse       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _dec        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _des        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _eicall     (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _eijmp      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _elpm1      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _elpm2      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _elpm3      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _eor        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _fmul       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _fmuls      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _fmulsu     (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _icall      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ijmp       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _in         (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _inc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _jmp        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lac        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _las        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lat        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld1        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld2        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld3        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd2    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd3    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd4    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd_12  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd_13  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ld_ldd_14  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ldi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lds        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lds_avrrc  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lpm1       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lpm2       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lpm3       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _lsr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _mov        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _movw       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _mul        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _muls       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _mulsu      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _neg        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _nop        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _or         (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _out        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _pop        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _push       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _rcall      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ret        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _reti       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _rjmp       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _ror        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbc        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbci       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbi        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbic       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbis       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbiw       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbrc       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sbrs       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sleep      (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _spm        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st1        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st2        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st3        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std2    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std3    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std4    (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std_12  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std_13  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _st_std_14  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sts        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sts_avrrc  (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _sub        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _subi       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _swap       (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _wdr        (prog_counter_t* pcounter, device_mem_t* devMem);
+uint8_t _xch        (prog_counter_t* pcounter, device_mem_t* devMem);
+
+
+#define HANDLER_REGISTERS {\
+	{&_adc,        0b0001110000000000,	0b0000001111111111,	2}, \
+	{&_add,        0b0000110000000000,	0b0000001111111111,	2}, \
+	{&_adiw,       0b1001011000000000,	0b0000000011111111,	2}, \
+	{&_and,        0b0010000000000000,	0b0000001111111111,	2}, \
+	{&_andi,       0b0111000000000000,	0b0000111111111111,	2}, \
+	{&_asr,        0b1001010000000101,	0b0000000111110000,	2}, \
+	{&_bclr,       0b1001010010001000,	0b0000000001110000,	2}, \
+	{&_bld,        0b1111100000000000,	0b0000000111110111,	2}, \
+	{&_brbc,       0b1111010000000000,	0b0000001111111111,	2}, \
+	{&_brbs,       0b1111000000000000,	0b0000001111111111,	2}, \
+	{&_break,      0b1001010110011000,	0b0000000000000000,	2}, \
+	{&_bset,       0b1001010000001000,	0b0000000001110000,	2}, \
+	{&_bst,        0b1111101000000000,	0b0000000111110111,	2}, \
+	{&_call,       0b1001010000001110,	0b0000000111110001,	4}, \
+	{&_cbi,        0b1001100000000000,	0b0000000011111111,	2}, \
+	{&_com,        0b1001010000000000,	0b0000000111110000,	2}, \
+	{&_cp,         0b0001010000000000,	0b0000001111111111,	2}, \
+	{&_cpc,        0b0000010000000000,	0b0000001111111111,	2}, \
+	{&_cpi,        0b0011000000000000,	0b0000111111111111,	2}, \
+	{&_cpse,       0b0001000000000000,	0b0000001111111111,	2}, \
+	{&_dec,        0b1001010000001010,	0b0000000111110000,	2}, \
+	{&_eicall,     0b1001010100011001,	0b0000000000000000,	2}, \
+	{&_eijmp,      0b1001010000011001,	0b0000000000000000,	2}, \
+	{&_elpm1,      0b1001010111011000,	0b0000000000000000,	2}, \
+	{&_elpm2,      0b1001000000000110,	0b0000000111110000,	2}, \
+	{&_elpm3,      0b1001000000000111,	0b0000000111110000,	2}, \
+	{&_eor,        0b0010010000000000,	0b0000001111111111,	2}, \
+	{&_fmul,       0b0000001100001000,	0b0000000001110111,	2}, \
+	{&_fmuls,      0b0000001110000000,	0b0000000001110111,	2}, \
+	{&_fmulsu,     0b0000001110001000,	0b0000000001110111,	2}, \
+	{&_icall,      0b1001010100001001,	0b0000000000000000,	2}, \
+	{&_ijmp,       0b1001010000001001,	0b0000000000000000,	2}, \
+	{&_in,         0b1011000000000000,	0b0000011111111111,	2}, \
+	{&_inc,        0b1001010000000011,	0b0000000111110000,	2}, \
+	{&_jmp,        0b1001010000001100,	0b0000000111110001,	4}, \
+	{&_ld1,        0b1001000000001100,	0b0000000111110000,	2}, \
+	{&_ld2,        0b1001000000001101,	0b0000000111110000,	2}, \
+	{&_ld3,        0b1001000000001110,	0b0000000111110000,	2}, \
+	{&_ld_ldd2,    0b1001000000001001,	0b0000000111110000,	2}, \
+	{&_ld_ldd3,    0b1001000000001010,	0b0000000111110000,	2}, \
+	{&_ld_ldd4,    0b1000000000001000,	0b0010110111110111,	2}, \
+	{&_ld_ldd_12,  0b1001000000000001,	0b0000000111110000,	2}, \
+	{&_ld_ldd_13,  0b1001000000000010,	0b0000000111110000,	2}, \
+	{&_ld_ldd_14,  0b1000000000000000,	0b0010110111110111,	2}, \
+	{&_ldi,        0b1110000000000000,	0b0000111111111111,	2}, \
+	{&_lds,        0b1001000000000000,	0b0000000111110000,	4}, \
+	{&_lpm1,       0b1001010111001000,	0b0000000000000000,	2}, \
+	{&_lpm2,       0b1001000000000100,	0b0000000111110000,	2}, \
+	{&_lpm3,       0b1001000000000101,	0b0000000111110000,	2}, \
+	{&_lsr,        0b1001010000000110,	0b0000000111110000,	2}, \
+	{&_mov,        0b0010110000000000,	0b0000001111111111,	2}, \
+	{&_movw,       0b0000000100000000,	0b0000000011111111,	2}, \
+	{&_mul,        0b1001110000000000,	0b0000001111111111,	2}, \
+	{&_muls,       0b0000001000000000,	0b0000000011111111,	2}, \
+	{&_mulsu,      0b0000001100000000,	0b0000000001110111,	2}, \
+	{&_neg,        0b1001010000000001,	0b0000000111110000,	2}, \
+	{&_nop,        0b0000000000000000,	0b0000000000000000,	2}, \
+	{&_or,         0b0010100000000000,	0b0000001111111111,	2}, \
+	{&_out,        0b1011100000000000,	0b0000011111111111,	2}, \
+	{&_pop,        0b1001000000001111,	0b0000000111110000,	2}, \
+	{&_push,       0b1001001000001111,	0b0000000111110000,	2}, \
+	{&_rcall,      0b1101000000000000,	0b0000111111111111,	2}, \
+	{&_ret,        0b1001010100001000,	0b0000000000000000,	2}, \
+	{&_reti,       0b1001010100011000,	0b0000000000000000,	2}, \
+	{&_rjmp,       0b1100000000000000,	0b0000111111111111,	2}, \
+	{&_ror,        0b1001010000000111,	0b0000000111110000,	2}, \
+	{&_sbc,        0b0000100000000000,	0b0000001111111111,	2}, \
+	{&_sbci,       0b0100000000000000,	0b0000111111111111,	2}, \
+	{&_sbi,        0b1001101000000000,	0b0000000011111111,	2}, \
+	{&_sbic,       0b1001100100000000,	0b0000000011111111,	2}, \
+	{&_sbis,       0b1001101100000000,	0b0000000011111111,	2}, \
+	{&_sbiw,       0b1001011100000000,	0b0000000011111111,	2}, \
+	{&_sbr,        0b0110000000000000,	0b0000111111111111,	2}, \
+	{&_sbrc,       0b1111110000000000,	0b0000000111110111,	2}, \
+	{&_sbrs,       0b1111111000000000,	0b0000000111110111,	2}, \
+	{&_sleep,      0b1001010110001000,	0b0000000000000000,	2}, \
+	{&_st1,        0b1001001000001100,	0b0000000111110000,	2}, \
+	{&_st2,        0b1001001000001101,	0b0000000111110000,	2}, \
+	{&_st3,        0b1001001000001110,	0b0000000111110000,	2}, \
+	{&_st_std2,    0b1001001000001001,	0b0000000111110000,	2}, \
+	{&_st_std3,    0b1001001000001010,	0b0000000111110000,	2}, \
+	{&_st_std4,    0b1000001000001000,	0b0010110111110111,	2}, \
+	{&_st_std_12,  0b1001001000000001,	0b0000000111110000,	2}, \
+	{&_st_std_13,  0b1001001000000010,	0b0000000111110000,	2}, \
+	{&_st_std_14,  0b1000001000000000,	0b0010110111110111,	2}, \
+	{&_sts,        0b1001001000000000,	0b0000000111110000,	4}, \
+	{&_sub,        0b0001100000000000,	0b0000001111111111,	2}, \
+	{&_subi,       0b0101000000000000,	0b0000111111111111,	2}, \
+	{&_swap,       0b1001010000000010,	0b0000000111110000,	2}, \
+	{&_wdr,        0b1001010110101000,	0b0000000000000000,	2}	}
+#endif // ifndef __GENERATED_INSTR_H__

inc/instr.h

@@ -57,4 +57,16 @@ opcode_t extractOpcode(device_mem_t* devMem, prog_counter_t programCounter);
 
 
 
+
+#define AVRe 1
+#define AVRxm 2
+#define AVRxt 3
+#define AVRrc 4
+
+#ifndef ARCH
+#define ARCH AVRe
+#endif
+
+
+
 #endif // ifndef __INSTR_H__

inc/instr_map.h

@@ -4,10 +4,6 @@
 #include "mem.h"
 #include <stdio.h>
 #include "addrs.h"
-
+#include "generated.h"
-uint8_t _nop        (prog_counter_t* pcounter, device_mem_t* devMem);
-
-#define HANDLER_REGISTERS {\
-	{&_nop,        0b0000000000000000,	0b1111111111111111,	2}} 
 
 #endif

inc/mem_seg.h

@@ -12,12 +12,22 @@
 #define MEMDATA_PS MEMSEG_PS
 
 
+
+#define MEMDATA_GP_REGS 1
+#define MEMDATA_IO_REGS 2
+#define MEMDATA_DS     3
+#define MEMDATA_OPSIZE  5
+
+
 #define MEMSEG_PC_SEG_NUM 1
 #define MEMSEG_PC_ADDR 0
 
 #define MEMSEG_DEFINES {\
-	{MEMSEG_PS, "PS", 2, 1024, 0, 1}, \
+	{MEMSEG_PS, "PS", 2, 1024, 2, 1}, \
-	{MEMSEG_PC_SEG_NUM, "PC", 2, 1, 1024 + MEMSEG_PC_ADDR + 1, 0} \
+	{MEMSEG_PC_SEG_NUM, "PC", 2, 1, 0, 0}, \
+	{MEMDATA_IO_REGS, "IO_REG", 1, 255, (1024 * 2) + 2, 0}, \
+	{MEMDATA_GP_REGS, "GP_REG", 1, 32, (1024 * 2) + 2 + 255, 0}, \
+	{MEMDATA_DS, "DS", 1, 65535, 2, 0} \
 }
 
 #endif //ifndef __MEM_SEG_H__

inc/runner.h

@@ -2,9 +2,10 @@
 #define __RUNNER_H__
 
 #include <stdint.h>
+#include "instr.h"
 #include "mem.h"
 
-uint8_t makeTick(device_mem_t* devMem);
+uint8_t makeTick(prog_counter_t* programCounter, instr_h_func* funcarr, device_mem_t* devMem);
 
 
 #endif // ifndef __RUNNER_H__

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;
+    // uint64_t offset = 0;
-    for (uint8_t i = 0; i < seg; i++)
+    // for (uint8_t i = 0; i < seg; i++)
-    {
+    // {
-        offset += spec->memSpecs[i]->len * spec->memSpecs[i]->wordLen;
+    //     offset += spec->memSpecs[i]->len * spec->memSpecs[i]->wordLen;
-    }
+    // }
-    return offset + localaddr;
+    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,11 +364,35 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
     devMem->smartAddrWriteMask = smartAddrWriteMask;
     devMem->smartAddrWriteHandlers = smartAddrWriteHandlers;
     devMem->memsegNames = cellNames;
+    devMem->memsegSizes = memsegSizes;
+
+    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]->len = 32;
-    specs->memSpecs[1]->start = 256;
+    specs->memSpecs[1]->start = (1024 * OPCODE_WORDSIZE);
-    specs->memSpecs[1]->wordLen = 1;
+    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++)
+    {
+        if(i != MEMDATA_OPSIZE)
         {
             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;
 }
+

src/instr.c

@@ -7,6 +7,7 @@
 
 #include "instr_map.h"
 #include "mem_seg.h"
+#include "generated.h"
 
 
 uint8_t _invalid_opcode(prog_counter_t* pcounter, device_mem_t* devMem)

src/main.c

@@ -0,0 +1,11 @@
+
+
+#include "mem.h"
+#include "device.h"
+
+
+int main()
+{
+    device_public_context_t* devInfo = initDefault(NULL, 0, NULL, 0, NULL);
+    return 0;
+}

src/runner.c

@@ -2,7 +2,9 @@
 #include <stdio.h>
 
 
-uint8_t makeTick(device_mem_t* devMem)
+uint8_t makeTick(prog_counter_t* programCounter, instr_h_func* funcarr, device_mem_t* devMem)
 {   
-    return 0;
+    opcode_t op = extractOpcode(devMem, *programCounter);
+    instr_h_func func = funcarr[op];
+    return func(programCounter, devMem);
 }