Initial commit

.gitignore

@@ -0,0 +1,2 @@
+*.o
+m16vm

Makefile

@@ -0,0 +1,15 @@
+
+CC = gcc
+CFLAGS = -DMEM_SIZE=32
+LD = $(CC)
+
+VM = m16vm
+
+$(VM) : src/vm.o src/cpu.o src/mm.o src/instr.o src/syscall.o
+	$(LD) $(LDFLAGS)-o $@ $^
+
+clean :
+	$(RM) src/*.o
+
+distclean : clean
+	$(RM) $(VM)

design.txt

@@ -0,0 +1,81 @@
+
+* 8 16-bit registers
+
+* Memory
+	4096 bytes. address aligned by 2 bytes (16 bit)
+
+
+* instruction set (16 bit)
+
+0001 - add
+0010 - movl (move low byte)
+0011 - movh (move high byte)
+0100 - load word
+0101 - store word
+0110 - beq
+0111 - jmp
+1000 - jr (jump register)
+
+1111 - I/O Write
+
+I/O = only 8 bits, syscall?
+
+--- Format ---
+
+Register operation format (R):
+
+	opcode (4) | rs (4)  | r0 (4) | r1 (4)
+
+	r0,r1 	- Operand registers.
+	rs   	- save register
+
+Register operation format (RI):
+
+	opcode (4) | rs (4)  | r0 (4) | offset (signed 4)
+
+	r0 	- Operand registers.
+	offset  - constant offset from r0 value.
+	rs   	- save register
+
+Constant operation format (I):
+
+	opcode (4) | reg (4) | data (signed 8)
+
+	reg - Register
+	data - Constant data to insert into reg.
+
+Jump format (J):
+
+	opcode (4) | addr (signed 12)
+
+
+
+* load ascii hex from file.
+* jump, branch instructions
+
+start:
+add r0, r4 # r4 = 1
+
+beq r0, r1
+jmp 2
+jmp 3
+load r3
+jr r3
+write r0
+
+
+if (r0 == r1)
+	jmp(b1);
+else
+	jmp(b2);
+b1:
+	load(r3);
+	jmpl(r3);
+b2:
+	write(r0);
+
+
+while (r0 == r1)
+	r0++;
+
+beq r0 r1 #

programs/hello_world.m16

@@ -0,0 +1 @@
+ Hπ  Eπ !Lρ ρ "Oς   π  Wπ ς  Rπ ρ  Dπ 

src/cpu.c

@@ -0,0 +1,169 @@
+/* cpu.c
+ *
+ *   Copyright (C) 2012,2014-2015   Henrik Hautakoski <henrik.hautakoski@gmail.com>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *   MA 02110-1301, USA.
+ */
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include "cpu.h"
+#include "mm.h"
+#include "syscall.h"
+#include "instr.h"
+
+// Registers r0, r15
+int16_t reg[16] = { 0 };
+
+/* Program */
+unsigned char *instr_mem = NULL;
+unsigned long instr_cnt = 0;
+
+/* Program counter */
+uint16_t pc = 0;
+
+/* CPU flags */
+#define CPU_FLAGS_HALT (1<<0)
+unsigned char cpu_flags = CPU_FLAGS_HALT;
+
+#define debug(...) fprintf(stderr, __VA_ARGS__)
+
+static void execute(struct instr *instr) {
+
+	switch(instr->opcode) {
+	case OP_NOOP :
+		debug("noop\n");
+		/* Do nothing */
+		break;
+	case OP_ADD :
+		debug("add\tr%i r%i r%i\n", instr->r.rs, instr->r.r0, instr->r.r1);
+		reg[instr->r.rs] = reg[instr->r.r0] + reg[instr->r.r1];
+		break;
+	case OP_MOVL :
+		debug("movl\tr%i #%i\n", instr->i.rs, instr->i.imm);
+		reg[instr->r.rs] = (reg[instr->r.rs] & 0xFF00) | instr->i.imm;
+		break;
+	case OP_MOVH :
+		debug("movh\tr%i #%i\n", instr->i.rs, instr->i.imm);
+		reg[instr->r.rs] = (reg[instr->r.rs] & 0x00FF) | (((uint16_t) instr->i.imm) << 8);
+		break;
+	case OP_LW :
+		debug("lw\tr%i r%i #%i\n", instr->r.rs, instr->r.r0, instr->r.r1);
+		reg[instr->r.rs] = mm_lw(reg[instr->r.r0] + instr->r.r1);
+		break;
+	case OP_SW :
+		debug("sw\tr%i r%i #%i\n", instr->r.rs, instr->r.r0, instr->r.r1);
+		mm_sw(reg[instr->r.rs] + instr->r.r1, reg[instr->r.r0]);
+		break;
+	case OP_JMP :
+		debug("jmp\t#%i\n", instr->j.addr);
+		cpu_set_pc(instr->j.addr);
+		break;
+	case OP_JR :
+		debug("jr\t#r%i(#%i)\n", instr->i.rs, instr->i.imm);
+		break;
+	case OP_BEQ :
+		debug("beq\tr%i r%i #%i\n", instr->ri.rs, instr->ri.r0, instr->ri.offset);
+		// Compare rs, r0
+		if (reg[instr->ri.rs] == reg[instr->ri.r0])
+			cpu_set_pc(pc + instr->ri.offset);
+		break;
+	case OP_SYSC_WR :
+		debug("I/O write r%i: %i\n", instr->r.rs, reg[instr->r.rs]);
+		syscall_write(reg[instr->i.rs], instr->i.imm);
+		break;
+	default :
+		fprintf(stderr, "Invalid instruction (%.2X)\n", instr->opcode);
+		cpu_flags |= CPU_FLAGS_HALT;
+		break;
+	}
+}
+
+void print_memory() {
+
+	int i = 0;
+
+	printf("\n");
+
+	for(i = 0; i < 32; i++) {
+		printf("%.2X ", memory[i]);
+	}
+	printf("\n");
+}
+
+static unsigned char* instr_fetch() {
+
+	if (pc + 1 >= instr_cnt >> 1)
+		cpu_flags |= CPU_FLAGS_HALT;
+
+	return instr_mem + (pc++ << 1);
+}
+
+int cpu_instr_load(void *ptr, unsigned len) {
+
+	if (len % 2) {
+		fprintf(stderr, "Error: Instruction length must be a multiple of 2\n");
+		return -1;
+	}
+
+	instr_mem = ptr;
+	instr_cnt = len;
+	return len;
+}
+
+void cpu_instr_unload() {
+
+	instr_mem = NULL;
+	instr_cnt = 0;
+}
+
+void cpu_set_pc(uint16_t addr) {
+
+	if (addr > instr_cnt / 2) {
+		fprintf(stderr, "Runtime error: Invalid instruction address %ui\n", addr);
+		cpu_flags |= CPU_FLAGS_HALT;
+		return;
+	}
+	pc = addr;
+}
+
+void cpu_run() {
+
+	mm_init();
+
+	cpu_flags &= ~CPU_FLAGS_HALT;
+
+	while(!(cpu_flags & CPU_FLAGS_HALT)) {
+		struct instr instr;
+		unsigned char* next = instr_fetch();
+
+		// decode instruction.
+		instr_decode(next, &instr);
+
+		// Execute it.
+		execute(&instr);
+	}
+
+	print_memory();
+
+	mm_exit();
+}

src/cpu.h

@@ -0,0 +1,34 @@
+/* cpu.h
+ *
+ *   Copyright (C) 2012,2014-2015   Henrik Hautakoski <henrik.hautakoski@gmail.com>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *   MA 02110-1301, USA.
+ */
+#ifndef CPU_H
+#define CPU_H
+
+#include <stdint.h>
+#include "instr.h"
+
+int cpu_instr_load(void *ptr, unsigned len);
+
+void cpu_instr_unload();
+
+void cpu_set_pc(uint16_t addr);
+
+void cpu_run();
+
+#endif /* CPU_H */

src/instr.c

@@ -0,0 +1,52 @@
+/* instr.c
+ *
+ *   Copyright (C) 2012,2014   Henrik Hautakoski <henrik.hautakoski@gmail.com>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *   MA 02110-1301, USA.
+ */
+#include "instr.h"
+
+void instr_decode(unsigned char *instr, struct instr *out) {
+
+	out->opcode 	= *instr >> 4;
+
+	if (out->opcode == OP_NOOP)
+		return;
+
+	// J-Type
+	if (out->opcode == OP_JMP) {
+
+		out->j.addr = ((*instr & 0xF) << 8) + *(instr + 1);
+
+		// if MSB (bit 12) is set
+		// perform 2s complement by setting bit 13-16 to 1
+		/*
+		if (out->j.addr & 0x0800)
+			out->j.addr |= 0xF000; */
+	} else {
+		out->r.rs = *instr & 0xF;
+
+		// I-Type
+		if (out->opcode == OP_MOVL || out->opcode == OP_MOVH || out->opcode == OP_SYSC_WR) {
+			out->i.imm = *(instr + 1);
+		}
+		// R/RI-Type
+		else {
+			out->r.r0 = *(instr + 1) >> 4;
+			out->r.r1 = *(instr + 1) & 0xF;
+		}
+	}
+}

src/instr.h

@@ -0,0 +1,74 @@
+/* instr.h
+ *
+ *   Copyright (C) 2012,2014   Henrik Hautakoski <henrik.hautakoski@gmail.com>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *   MA 02110-1301, USA.
+ */
+#ifndef INSTR_H
+#define INSTR_H
+
+#include <stdint.h>
+
+/* Opcodes */
+#define OP_NOOP 	0
+#define OP_ADD		1
+#define OP_MOVL 	2
+#define OP_MOVH 	3
+#define OP_LW		4
+#define OP_SW   	5
+#define OP_BEQ  	6
+#define OP_JMP  	7
+#define OP_JR   	8
+
+/* System calls */
+#define OP_SYSC_RD	14 /* read char from stdin */
+#define OP_SYSC_WR 	15 /* write char to stdout */
+
+/* Register type */
+struct instr_R {
+	uint8_t rs;
+	uint8_t r0;
+	uint8_t r1;
+};
+
+struct instr_RI {
+	uint8_t rs;
+	uint8_t r0;
+	int8_t 	offset;
+};
+
+struct instr_I {
+	uint8_t  rs;
+	int8_t   imm;
+};
+
+struct instr_J {
+	uint16_t addr;
+};
+
+struct instr {
+	uint8_t opcode;
+	union {
+		struct instr_R  r;
+		struct instr_RI ri;
+		struct instr_I  i;
+		struct instr_J  j;
+	};
+};
+
+void instr_decode(unsigned char *nibble, struct instr *instr);
+
+#endif /* INSTR_H */

src/mm.c

@@ -0,0 +1,69 @@
+/* mm.c
+ *
+ *   Copyright (C) 2012,2014   Henrik Hautakoski <henrik.hautakoski@gmail.com>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *   MA 02110-1301, USA.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "mm.h"
+
+#ifndef MEM_SIZE
+/* Set a default memory size. (2^16) */
+#define MEM_SIZE 65536
+#endif
+
+#define EXCEPTION_STRING "Runtime exception: Memory address '%u' is out of bounds.\n"
+
+int16_t* base_addr = NULL;
+uint8_t *memory = NULL;
+
+static void check_bounds(uint16_t addr) {
+
+	if (addr > MEM_SIZE) {
+		fprintf(stderr, EXCEPTION_STRING, addr);
+		exit(1);
+	}
+}
+
+void mm_init() {
+
+	base_addr = malloc(MEM_SIZE);
+	memory = (uint8_t*) base_addr;
+}
+
+void mm_exit() {
+
+	if (base_addr) {
+		free(base_addr);
+		base_addr = NULL;
+		memory = NULL;
+	}
+}
+
+void mm_sw(uint16_t addr, int16_t value) {
+
+	check_bounds(addr);
+
+	base_addr[addr] = value;
+}
+
+int16_t mm_lw(uint16_t addr) {
+
+	check_bounds(addr);
+
+	return base_addr[addr];
+}

src/mm.h

@@ -0,0 +1,37 @@
+/* mm.h
+ *
+ *   Copyright (C) 2012,2014   Henrik Hautakoski <henrik.hautakoski@gmail.com>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *   MA 02110-1301, USA.
+ */
+#ifndef MM_H
+#define MM_H
+
+#include <stdint.h>
+
+extern uint8_t *memory;
+
+void mm_init();
+
+void mm_exit();
+
+/* Save a word to memory. */
+void mm_sw(uint16_t addr, int16_t value);
+
+/* Load a word from memory. */
+int16_t mm_lw(uint16_t addr);
+
+#endif /* MM_H */

src/syscall.c

@@ -0,0 +1,37 @@
+/* syscall.h
+*
+*   Copyright (C) 2012,2014-2015   Henrik Hautakoski <henrik.hautakoski@gmail.com>
+*
+*   This program is free software; you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation; either version 2 of the License, or
+*   (at your option) any later version.
+*
+*   This program is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with this program; if not, write to the Free Software
+*   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+*   MA 02110-1301, USA.
+*/
+#include <stdio.h>
+#include "syscall.h"
+
+void syscall_write(int16_t value, int8_t op) {
+
+	switch(op) {
+	case SYSW_INT16 :
+		printf("%i", value);
+		break;
+	case SYSW_INT8 :
+		printf("%i", (int8_t) value);
+		break;
+	case SYSW_CHAR :
+	default:
+		printf("%c", (unsigned char) value);
+		break;
+	}
+}

src/syscall.h

@@ -0,0 +1,32 @@
+/* syscall.h
+*
+*   Copyright (C) 2012,2014-2015   Henrik Hautakoski <henrik.hautakoski@gmail.com>
+*
+*   This program is free software; you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation; either version 2 of the License, or
+*   (at your option) any later version.
+*
+*   This program is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with this program; if not, write to the Free Software
+*   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+*   MA 02110-1301, USA.
+*/
+
+#ifndef SYSCALL_H
+#define SYSCALL_H
+
+#include <stdint.h>
+
+#define SYSW_INT16  0x0
+#define SYSW_INT8   0x1
+#define SYSW_CHAR   0x2
+
+void syscall_write(int16_t value, int8_t op);
+
+#endif /* SYSCALL_H */

src/vm.c

@@ -0,0 +1,80 @@
+/* vm.c
+ *
+ *   Copyright (C) 2012,2014   Henrik Hautakoski <henrik.hautakoski@gmail.com>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *   MA 02110-1301, USA.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include "cpu.h"
+
+// Load program from file
+unsigned long load_program(int fd, unsigned char **buf) {
+
+	struct stat st;
+	ssize_t rc;
+
+	if (fstat(fd, &st) < 0)
+		return -1;
+
+	*buf = malloc(st.st_size);
+	if (*buf == NULL)
+		return -1;
+
+	rc = read(fd, *buf, st.st_size);
+	if (rc < 0)
+		free(*buf);
+	return rc;
+}
+
+int main(int argc, char **argv) {
+
+	int fd;
+	unsigned char *instr_ptr;
+	unsigned instr_len;
+
+	if (argc < 2) {
+		fprintf(stderr, "usage: %s <file>\n", argv[0]);
+		return 1;
+	}
+
+	fd = open(argv[1], O_RDONLY);
+	if (fd < 0) {
+		fprintf(stderr, "Could not open file %s: %s\n",
+			argv[1], strerror(errno));
+		return 1;
+	}
+
+	instr_len = load_program(fd, &instr_ptr);
+	close(fd);
+
+	if (instr_len < 0)
+		return 1;
+
+	cpu_instr_load(instr_ptr, instr_len);
+
+	cpu_run();
+
+	if (instr_ptr)
+		free(instr_ptr);
+
+	return 0;
+}