jit-x64.dasc

#include <stdint.h>
#include "util.h"

|.arch x64
|.actionlist actions
|
|// Use rbx as our cell pointer.
|// Since rbx is a callee-save register, it will be preserved
|// across our calls to getchar and putchar.
|.define PTR, rbx
|
|// Macro for calling a function.
|// In cases where our target is <=2**32 away we can use
|//   | call &addr
|// But since we don't know if it will be, we use this safe
|// sequence instead.
|.macro callp, addr
|  mov64  rax, (uintptr_t)addr
|  call   rax
|.endmacro

#define Dst &state
#define MAX_NESTING 256

int main(int argc, char *argv[])
{
	if (argc < 2) err("Usage: jit-x64 <inputfile>");
	dasm_State *state;
	initjit(&state, actions);

	unsigned int maxpc = 0;
	int pcstack[MAX_NESTING];
	int *top = pcstack, *limit = pcstack + MAX_NESTING;

	// Function prologue.
	|  push PTR
	|  mov  PTR, rdi      // rdi store 1st argument

	for (char *p = read_file(argv[1]); *p; p++) {
		switch (*p) {
		case '>':
			|  inc  PTR
			break;
		case '<':
			|  dec  PTR
			break;
		case '+':
			|  inc  byte [PTR]
			break;
		case '-':
			|  dec  byte [PTR]
			break;
		case '.':
			|  movzx edi, byte [PTR]
			|  callp putchar
			break;
		case ',':
			|  callp getchar
			|  mov   byte [PTR], al
			break;
		case '[':
			if (top == limit) err("Nesting too deep.");
			// Each loop gets two pclabels: at the beginning and end.
			// We store pclabel offsets in a stack to link the loop
			// begin and end together.
			maxpc += 2;
			*top++ = maxpc;
			dasm_growpc(&state, maxpc);
			|  cmp  byte [PTR], 0
			|  je   =>(maxpc-2)
			|=>(maxpc-1):
			break;
		case ']':
			if (top == pcstack) err("Unmatched ']'");
			top--;
			|  cmp  byte [PTR], 0
			|  jne  =>(*top-1)
			|=>(*top-2):
			break;
		}
	}

	// Function epilogue.
	|  pop  PTR
	|  ret

	void (*fptr)(char*) = jitcode(&state);
	char *mem = calloc(30000, 1);
	fptr(mem);
	free(mem);
	free_jitcode(fptr);
	return 0;
}