Apply asie's first performance patch

9 files changed, 539 insertions, 123 deletions

diff --git a/src/bd-font.c b/src/bd-font.c
index 6913f78..0374496 100644
--- a/src/bd-font.c
+++ b/src/bd-font.c
@@ -9,7 +9,7 @@ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 WITH REGARD TO THIS SOFTWARE.
 */
 
-u32 bd_font[] = {
+static const u32 bd_font[] = {
     0x00000000, 0x00000000, 0x00002400, 0x423c0000,
     0x00002400, 0x3c420000, 0x0000363e, 0x3e1c0800,
     0x00081c3e, 0x3e1c0800, 0x001c1c3e, 0x363e081c,
diff --git a/src/common.h b/src/common.h
index 2859b11..e293770 100644
--- a/src/common.h
+++ b/src/common.h
@@ -666,7 +666,7 @@ typedef enum {
     NOTE_C_8
 } Note;
 
-const char * note_names[] =  {
+static const char * note_names[] =  {
     "C2", "C#2", "D2", "D#2", "E2", "F2", "F#2", "G2", "G#2", "A2", "A#2", "B2",
     "C3", "C#3", "D3", "D#3", "E3", "F3", "F#3", "G3", "G#3", "A3", "A#3", "B3",
     "C4", "C#4", "D4", "D#4", "E4", "F4", "F#4", "G4", "G#4", "A4", "A#4", "B4",
@@ -676,7 +676,7 @@ const char * note_names[] =  {
     "C8"
 };
 
-const u32 sound_rates[] = {
+static const u32 sound_rates[] = {
     44  , 156 , 262 , 363 , 457 , 547 , 631 , 710 , 785 , 856 , 923 , 986 ,
     1046, 1102, 1155, 1205, 1252, 1297, 1339, 1379, 1416, 1452, 1485, 1517,
     1547, 1575, 1601, 1626, 1650, 1672, 1693, 1713, 1732, 1750, 1766, 1782,
@@ -704,4 +704,10 @@ wait_vsync(void) {
 #define MAX(A, B) ((A) >= (B) ? (A) : (B))
 #define CLAMP(X, MIN, MAX) ((X) <= (MIN) ? (MIN) : (X) > (MAX) ? (MAX): (X))
 
+// IWRAM allocation macros for devkitARM.
+#define IWRAM_CODE __attribute__((section(".iwram"), long_call, target("arm")))
+#define IWRAM_DATA __attribute__((section(".iwram")))
+#define EWRAM_DATA __attribute__((section(".ewram")))
+#define EWRAM_BSS __attribute__((section(".sbss")))
+
 #endif // GBAEXP_COMMON_H
diff --git a/src/main.c b/src/main.c
index 5edf71c..bdff100 100644
--- a/src/main.c
+++ b/src/main.c
@@ -61,6 +61,7 @@ system_talk(Device *d, Uint8 b0, Uint8 w) {
     (void)b0;
 }
 
+IWRAM_CODE
 void
 screen_talk(Device *d, Uint8 b0, Uint8 w) {
     if(w && b0 == 0xe) {
@@ -181,6 +182,10 @@ handle_input(Uxn *u) {
     devctrl->dat[3] = 0;
 }
 
+static Uxn u;
+EWRAM_BSS
+static Uint8 umem[65536];
+
 int main(void) {
     // Register interrupts.
     irq_init();
@@ -188,7 +193,8 @@ int main(void) {
 
 
     // Initialize VM.
-    Uxn u = {0};
+    memset(&u, 0, sizeof(u));
+    u.ram.dat = umem;
     init_uxn(&u);
 
     // Initialize text engine.
@@ -208,10 +214,13 @@ int main(void) {
     while(true) {
         bios_vblank_wait();
         handle_input(&u);
+        profile_start();
         evaluxn(&u, mempeek16(devscreen->dat, 0));
+        int eval_cycles = profile_stop();
         flipbuf(&ppu);
-        // txt_position(0,0);
-        // txt_printf("FRAME: %d\n", frame_counter);
+        txt_position(0,0);
+        txt_printf("FRAME: %d\n", frame_counter);
+        txt_printf("EVAL: %d\n", eval_cycles);
         time_seconds++;
         frame_counter++;
     }
diff --git a/src/small-font.c b/src/small-font.c
index e5adb35..6405f88 100644
--- a/src/small-font.c
+++ b/src/small-font.c
@@ -9,7 +9,7 @@ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 WITH REGARD TO THIS SOFTWARE.
 */
 
-u32 small_font[] = {
+static const u32 small_font[] = {
     0x00000000, 0x00000000, 0x00020202, 0x00020000,
     0x000a0a00, 0x00000000, 0x000a1f0a, 0x1f0a0000,
     0x02070107, 0x04070200, 0x00010402, 0x01040000,
diff --git a/src/text.h b/src/text.h
index 0b318bb..eb6149d 100644
--- a/src/text.h
+++ b/src/text.h
@@ -255,7 +255,10 @@ txt_printf(char *msg, ...) {
     va_list arg_list;
     va_start(arg_list, msg);
     char buf[512] = {0};
-    vsprintf(buf, msg, arg_list);
+    // TODO: This call pulls in malloc() and a bunch of other things.
+    // To reduce memory usage and filesize, it would be advisable
+    // to replace it with something simpler.
+    vsiprintf(buf, msg, arg_list);
     txt_puts(buf);
 }
 
diff --git a/src/uxn/devices/ppu.c b/src/uxn/devices/ppu.c
index e9a94a6..60ede0a 100644
--- a/src/uxn/devices/ppu.c
+++ b/src/uxn/devices/ppu.c
@@ -142,8 +142,10 @@ static Uint32 unpack_icon_lut_flipx[256] = {
     0x11111111
 };
 
-u32 *backbuffer_bg0;
-u32 *backbuffer_bg1;
+EWRAM_BSS
+static u32 *backbuffer_bg0[30 * 20 * sizeof(Tile) / 4];
+EWRAM_BSS
+static u32 *backbuffer_bg1[30 * 20 * sizeof(Tile) / 4];
 static u32 dirty_tiles[20] = {0};
 
 void
@@ -161,6 +163,7 @@ putcolors(Ppu *p, Uint8 *addr) {
     }
 }
 
+IWRAM_CODE
 void
 putpixel(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 color) {
     if(x >= 30 * 8 || y >= 20 * 8) {
@@ -176,6 +179,7 @@ putpixel(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 color) {
     dirty_tiles[tile_y] |= 1 << tile_x;
 }
 
+IWRAM_CODE
 void
 puticn(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color,
         Uint8 flipx, Uint8 flipy) {
@@ -230,6 +234,7 @@ puticn(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color,
     }
 }
 
+IWRAM_CODE
 void
 putchr(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color,
         Uint8 flipx, Uint8 flipy) {
@@ -249,6 +254,7 @@ putchr(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color,
         }
 }
 
+IWRAM_CODE
 void
 flipbuf(Ppu *p) {
     Tile *mem_fg = &TILE_MEM[0];
@@ -289,9 +295,6 @@ initppu(Ppu *p, Uint8 hor, Uint8 ver, Uint8 pad) {
     BG_CTRL(0) = BG_CHARBLOCK(cb_fg) | BG_SCREENBLOCK(sb_idx) | BG_PRIORITY(1);
     BG_CTRL(1) = BG_CHARBLOCK(cb_bg) | BG_SCREENBLOCK(sb_idx) | BG_PRIORITY(2);
 
-    backbuffer_bg0 = malloc(30 * 20 * sizeof(Tile));
-    backbuffer_bg1 = malloc(30 * 20 * sizeof(Tile));
-
     // Clear tile memory.
     p->fg = backbuffer_bg0;
     p->bg = backbuffer_bg1;
diff --git a/src/uxn/uxn.c b/src/uxn/uxn.c
index 54d56d0..c1c564a 100644
--- a/src/uxn/uxn.c
+++ b/src/uxn/uxn.c
@@ -3,6 +3,7 @@
 
 /*
 Copyright (u) 2021 Devine Lu Linvega
+Copyright (u) 2021 Adrian Siekierka
 
 Permission to use, copy, modify, and distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
@@ -12,125 +13,144 @@ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 WITH REGARD TO THIS SOFTWARE.
 */
 
-#pragma mark - Operations
-
 /* clang-format off */
-void   push8(Stack *s, Uint8 a) { if (s->ptr == 0xff) { s->error = 2; return; } s->dat[s->ptr++] = a; }
-Uint8  pop8_keep(Stack *s) { if (s->kptr == 0) { s->error = 1; return 0; } return s->dat[--s->kptr]; }
-Uint8  pop8_nokeep(Stack *s) { if (s->ptr == 0) { s->error = 1; return 0; } return s->dat[--s->ptr]; }
-static Uint8 (*pop8)(Stack *s);
-void   mempoke8(Uint8 *m, Uint16 a, Uint8 b) { m[a] = b; }
-Uint8  mempeek8(Uint8 *m, Uint16 a) { return m[a]; }
-void   devpoke8(Device *d, Uint8 a, Uint8 b) { d->dat[a & 0xf] = b; d->talk(d, a & 0x0f, 1); }
-Uint8  devpeek8(Device *d, Uint8 a) { d->talk(d, a & 0x0f, 0); return d->dat[a & 0xf];  }
-void   push16(Stack *s, Uint16 a) { push8(s, a >> 8); push8(s, a); }
-Uint16 pop16(Stack *s) { return pop8(s) + (pop8(s) << 8); }
-void   mempoke16(Uint8 *m, Uint16 a, Uint16 b) { mempoke8(m, a, b >> 8); mempoke8(m, a + 1, b); }
-Uint16 mempeek16(Uint8 *m, Uint16 a) { return (mempeek8(m, a) << 8) + mempeek8(m, a + 1); }
-void   devpoke16(Device *d, Uint8 a, Uint16 b) { devpoke8(d, a, b >> 8); devpoke8(d, a + 1, b); }
-Uint16 devpeek16(Device *d, Uint16 a) { return (devpeek8(d, a) << 8) + devpeek8(d, a + 1); }
-/* Stack */
-void op_brk(Uxn *u) { u->ram.ptr = 0; }
-void op_nop(Uxn *u) { (void)u; }
-void op_lit(Uxn *u) { push8(u->src, mempeek8(u->ram.dat, u->ram.ptr++)); }
-void op_pop(Uxn *u) { pop8(u->src); }
-void op_dup(Uxn *u) { Uint8 a = pop8(u->src); push8(u->src, a); push8(u->src, a); }
-void op_swp(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, a); push8(u->src, b); }
-void op_ovr(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b); push8(u->src, a); push8(u->src, b); }
-void op_rot(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src), c = pop8(u->src); push8(u->src, b); push8(u->src, a); push8(u->src, c); }
-/* Logic */
-void op_equ(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b == a); }
-void op_neq(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b != a); }
-void op_gth(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b > a); }
-void op_lth(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b < a); }
-void op_jmp(Uxn *u) { Uint8 a = pop8(u->src); u->ram.ptr += (Sint8)a; }
-void op_jnz(Uxn *u) { Uint8 a = pop8(u->src); if (pop8(u->src)) u->ram.ptr += (Sint8)a; }
-void op_jsr(Uxn *u) { Uint8 a = pop8(u->src); push16(u->dst, u->ram.ptr); u->ram.ptr += (Sint8)a; }
-void op_sth(Uxn *u) { Uint8 a = pop8(u->src); push8(u->dst, a); }
-/* Memory */
-void op_pek(Uxn *u) { Uint8 a = pop8(u->src); push8(u->src, mempeek8(u->ram.dat, a)); }
-void op_pok(Uxn *u) { Uint8 a = pop8(u->src); Uint8 b = pop8(u->src); mempoke8(u->ram.dat, a, b); }
-void op_ldr(Uxn *u) { Uint8 a = pop8(u->src); push8(u->src, mempeek8(u->ram.dat, u->ram.ptr + (Sint8)a)); }
-void op_str(Uxn *u) { Uint8 a = pop8(u->src); Uint8 b = pop8(u->src); mempoke8(u->ram.dat, u->ram.ptr + (Sint8)a, b); }
-void op_lda(Uxn *u) { Uint16 a = pop16(u->src); push8(u->src, mempeek8(u->ram.dat, a)); }
-void op_sta(Uxn *u) { Uint16 a = pop16(u->src); Uint8 b = pop8(u->src); mempoke8(u->ram.dat, a, b); }
-void op_dei(Uxn *u) { Uint8 a = pop8(u->src); push8(u->src, devpeek8(&u->dev[a >> 4], a)); }
-void op_deo(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); devpoke8(&u->dev[a >> 4], a, b); }
-/* Arithmetic */
-void op_add(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b + a); }
-void op_sub(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b - a); }
-void op_mul(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b * a); }
-void op_div(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b / a); }
-void op_and(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b & a); }
-void op_ora(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b | a); }
-void op_eor(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b ^ a); }
-void op_sft(Uxn *u) { Uint8 a = pop8(u->src), b = pop8(u->src); push8(u->src, b >> (a & 0x07) << ((a & 0x70) >> 4)); }
-/* Stack */
-void op_lit16(Uxn *u) { push16(u->src, mempeek16(u->ram.dat, u->ram.ptr++)); u->ram.ptr++; }
-void op_pop16(Uxn *u) { pop16(u->src); }
-void op_dup16(Uxn *u) { Uint16 a = pop16(u->src); push16(u->src, a); push16(u->src, a); }
-void op_swp16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push16(u->src, a); push16(u->src, b); }
-void op_ovr16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push16(u->src, b); push16(u->src, a); push16(u->src, b); }
-void op_rot16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src), c = pop16(u->src); push16(u->src, b); push16(u->src, a); push16(u->src, c); }
-/* Logic(16-bits) */
-void op_equ16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push8(u->src, b == a); }
-void op_neq16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push8(u->src, b != a); }
-void op_gth16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push8(u->src, b > a); }
-void op_lth16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push8(u->src, b < a); }
-void op_jmp16(Uxn *u) { u->ram.ptr = pop16(u->src); }
-void op_jnz16(Uxn *u) { Uint16 a = pop16(u->src); if (pop8(u->src)) u->ram.ptr = a; }
-void op_jsr16(Uxn *u) { push16(u->dst, u->ram.ptr); u->ram.ptr = pop16(u->src); }
-void op_sth16(Uxn *u) { Uint16 a = pop16(u->src); push16(u->dst, a); }
-/* Memory(16-bits) */
-void op_pek16(Uxn *u) { Uint8 a = pop8(u->src); push16(u->src, mempeek16(u->ram.dat, a)); }
-void op_pok16(Uxn *u) { Uint8 a = pop8(u->src); Uint16 b = pop16(u->src); mempoke16(u->ram.dat, a, b); }
-void op_ldr16(Uxn *u) { Uint8 a = pop8(u->src); push16(u->src, mempeek16(u->ram.dat, u->ram.ptr + (Sint8)a)); }
-void op_str16(Uxn *u) { Uint8 a = pop8(u->src); Uint16 b = pop16(u->src); mempoke16(u->ram.dat, u->ram.ptr + (Sint8)a, b); }
-void op_lda16(Uxn *u) { Uint16 a = pop16(u->src); push16(u->src, mempeek16(u->ram.dat, a)); }
-void op_sta16(Uxn *u) { Uint16 a = pop16(u->src); Uint16 b = pop16(u->src); mempoke16(u->ram.dat, a, b); }
-void op_dei16(Uxn *u) { Uint8 a = pop8(u->src); push16(u->src, devpeek16(&u->dev[a >> 4], a)); }
-void op_deo16(Uxn *u) { Uint8 a = pop8(u->src); Uint16 b = pop16(u->src); devpoke16(&u->dev[a >> 4], a, b); }
-/* Arithmetic(16-bits) */
-void op_add16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push16(u->src, b + a); }
-void op_sub16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push16(u->src, b - a); }
-void op_mul16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push16(u->src, b * a); }
-void op_div16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push16(u->src, b / a); }
-void op_and16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push16(u->src, b & a); }
-void op_ora16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push16(u->src, b | a); }
-void op_eor16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push16(u->src, b ^ a); }
-void op_sft16(Uxn *u) { Uint16 a = pop16(u->src), b = pop16(u->src); push16(u->src, b >> (a & 0x000f) << ((a & 0x00f0) >> 4)); }
-
-void (*ops[])(Uxn *u) = {
-        op_brk, op_lit, op_nop, op_pop, op_dup, op_swp, op_ovr, op_rot,
-        op_equ, op_neq, op_gth, op_lth, op_jmp, op_jnz, op_jsr, op_sth,
-        op_pek, op_pok, op_ldr, op_str, op_lda, op_sta, op_dei, op_deo,
-        op_add, op_sub, op_mul, op_div, op_and, op_ora, op_eor, op_sft,
-        /* 16-bit */
-        op_brk,   op_lit16, op_nop,   op_pop16, op_dup16, op_swp16, op_ovr16, op_rot16,
-        op_equ16, op_neq16, op_gth16, op_lth16, op_jmp16, op_jnz16, op_jsr16, op_sth16,
-        op_pek16, op_pok16, op_ldr16, op_str16, op_lda16, op_sta16, op_dei16, op_deo16,
-        op_add16, op_sub16, op_mul16, op_div16, op_and16, op_ora16, op_eor16, op_sft16
-};
+
+static inline void   push8(Stack *s, Uint8 a) {
+#ifdef CPU_ERROR_CHECKING
+        if (s->ptr == 0xff) { s->error = 2; return; }
+#endif
+        s->dat[s->ptr++] = a;
+}
+static inline Uint8  pop8_keep(Stack *s) {
+#ifdef CPU_ERROR_CHECKING
+        if (s->kptr == 0) { s->error = 1; return 0; }
+#endif
+        return s->dat[--s->kptr];
+}
+static inline Uint8  pop8_nokeep(Stack *s) {
+#ifdef CPU_ERROR_CHECKING
+        if (s->ptr == 0) { s->error = 1; return 0; }
+#endif
+        return s->dat[--s->ptr];
+}
+static inline void   devpoke8(Device *d, Uint8 a, Uint8 b) { d->dat[a & 0xf] = b; d->talk(d, a & 0x0f, 1); }
+static inline Uint8  devpeek8(Device *d, Uint8 a) { d->talk(d, a & 0x0f, 0); return d->dat[a & 0xf];  }
+static inline void   push16(Stack *s, Uint16 a) { push8(s, a >> 8); push8(s, a); }
+static inline void   devpoke16(Device *d, Uint8 a, Uint16 b) { devpoke8(d, a, b >> 8); devpoke8(d, a + 1, b); }
+static inline Uint16 devpeek16(Device *d, Uint16 a) { return (devpeek8(d, a) << 8) + devpeek8(d, a + 1); }
 
 /* clang-format on */
 
 #pragma mark - Core
 
-void
+int
+haltuxn(Uxn *u, char *name, int id)
+{
+        txt_printf("Halted: %s#%04x, at 0x%04x\n", name, id, u->ram.ptr);
+        u->ram.ptr = 0;
+        return 0;
+}
+
+IWRAM_CODE
+static inline void
 opcuxn(Uxn *u, Uint8 instr)
 {
-        Uint8 op = instr & 0x3f, freturn = instr & 0x40, fkeep = instr & 0x80;
-        u->src = freturn ? &u->rst : &u->wst;
-        u->dst = freturn ? &u->wst : &u->rst;
-        if(fkeep) {
-                pop8 = pop8_keep;
-                u->src->kptr = u->src->ptr;
+#ifdef CPU_ERROR_CHECKING
+        // With CPU error checking enabled, the codebase becomes too large to fit in ITCM.
+        // Therefore, we take some concessions.
+        if (instr & 0x40) {
+                u->src = &u->rst;
+                u->dst = &u->wst;
         } else {
-                pop8 = pop8_nokeep;
+                u->src = &u->wst;
+                u->dst = &u->rst;
+        }
+
+        switch (instr & 0xBF) {
+#define UXN_SRC (u->src)
+#define UXN_DST (u->dst)
+
+#define UXN_KEEP_SYNC {}
+#define pop8 pop8_nokeep
+#define pop16(s) (pop8((s)) + (pop8((s)) << 8))
+
+#define UXN_OPC(a) (a)
+#include "uxn/opcodes.c"
+#undef UXN_OPC
+
+#undef pop16
+#undef pop8
+#undef UXN_KEEP_SYNC
+
+#define UXN_KEEP_SYNC {(*(UXN_SRC)).kptr = (*(UXN_SRC)).ptr;}
+#define pop8 pop8_keep
+#define pop16(s) (pop8((s)) + (pop8((s)) << 8))
+
+#define UXN_OPC(a) (a | 0x80)
+#include "uxn/opcodes.c"
+#undef UXN_OPC
+
+#undef pop16
+#undef pop8
+#undef UXN_KEEP_SYNC
+
+#undef UXN_DST
+#undef UXN_SRC
+        }
+#else
+        switch (instr) {
+#define UXN_KEEP_SYNC {}
+#define pop8 pop8_nokeep
+#define pop16(s) (pop8((s)) + (pop8((s)) << 8))
+
+#define UXN_OPC(a) (a)
+#define UXN_SRC (&u->wst)
+#define UXN_DST (&u->rst)
+#include "uxn/opcodes.c"
+#undef UXN_DST
+#undef UXN_SRC
+#undef UXN_OPC
+
+#define UXN_OPC(a) (a | 0x40)
+#define UXN_SRC (&u->rst)
+#define UXN_DST (&u->wst)
+#include "uxn/opcodes.c"
+#undef UXN_DST
+#undef UXN_SRC
+#undef UXN_OPC
+
+#undef pop16
+#undef pop8
+#undef UXN_KEEP_SYNC
+
+#define UXN_KEEP_SYNC {(*(UXN_SRC)).kptr = (*(UXN_SRC)).ptr;}
+#define pop8 pop8_keep
+#define pop16(s) (pop8((s)) + (pop8((s)) << 8))
+
+#define UXN_OPC(a) (a | 0x80)
+#define UXN_SRC (&u->wst)
+#define UXN_DST (&u->rst)
+#include "uxn/opcodes.c"
+#undef UXN_DST
+#undef UXN_SRC
+#undef UXN_OPC
+
+#define UXN_OPC(a) (a | 0xC0)
+#define UXN_SRC (&u->rst)
+#define UXN_DST (&u->wst)
+#include "uxn/opcodes.c"
+#undef UXN_DST
+#undef UXN_SRC
+#undef UXN_OPC
+
+#undef pop16
+#undef pop8
+#undef UXN_KEEP_SYNC
         }
-        (*ops[op])(u);
+#endif
 }
 
+IWRAM_CODE
 int
 evaluxn(Uxn *u, Uint16 vec)
 {
diff --git a/src/uxn/uxn.h b/src/uxn/uxn.h
index b2c90ac..b24d058 100644
--- a/src/uxn/uxn.h
+++ b/src/uxn/uxn.h
@@ -28,7 +28,7 @@ typedef struct {
 
 typedef struct {
         Uint16 ptr;
-        Uint8 dat[KB(16)];
+        Uint8 *dat;
 } Memory;
 
 typedef struct Device {
@@ -45,8 +45,10 @@ typedef struct Uxn {
 
 struct Uxn;
 
-void mempoke16(Uint8 *m, Uint16 a, Uint16 b);
-Uint16 mempeek16(Uint8 *m, Uint16 a);
+static inline void   mempoke8(Uint8 *m, Uint16 a, Uint8 b) { m[a] = b; }
+static inline Uint8  mempeek8(Uint8 *m, Uint16 a) { return m[a]; }
+static inline void   mempoke16(Uint8 *m, Uint16 a, Uint16 b) { mempoke8(m, a, b >> 8); mempoke8(m, a + 1, b); }
+static inline Uint16 mempeek16(Uint8 *m, Uint16 a) { return (mempeek8(m, a) << 8) + mempeek8(m, a + 1); }
 
 int loaduxn(Uxn *c, char *filepath);
 int bootuxn(Uxn *c);
diff --git a/src/uxn/uxn/opcodes.c b/src/uxn/uxn/opcodes.c
new file mode 100644
index 0000000..947755f
--- /dev/null
+++ b/src/uxn/uxn/opcodes.c
@@ -0,0 +1,373 @@
+/*
+Copyright (u) 2021 Devine Lu Linvega
+Copyright (c) 2021 Adrian "asie" Siekierka
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE.
+*/
+
+/* 8-BIT OPCODES */
+
+case UXN_OPC(0x00):
+case UXN_OPC(0x20): { // brk
+        u->ram.ptr = 0;
+} break;
+case UXN_OPC(0x01): { // lit
+        push8(UXN_SRC, mempeek8(u->ram.dat, u->ram.ptr++));
+} break;
+case UXN_OPC(0x02):
+case UXN_OPC(0x22): { // nop
+} break;
+case UXN_OPC(0x03): { // pop
+        UXN_KEEP_SYNC;
+        pop8(UXN_SRC);
+} break;
+case UXN_OPC(0x04): { // dup
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        push8(UXN_SRC, a);
+        push8(UXN_SRC, a);
+} break;
+case UXN_OPC(0x05): { // swp
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, a);
+        push8(UXN_SRC, b);
+} break;
+case UXN_OPC(0x06): { // ovr
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b);
+        push8(UXN_SRC, a);
+        push8(UXN_SRC, b);
+} break;
+case UXN_OPC(0x07): { // rot
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        Uint8 c = pop8(UXN_SRC);
+        push8(UXN_SRC, b);
+        push8(UXN_SRC, a);
+        push8(UXN_SRC, c);
+} break;
+case UXN_OPC(0x08): { // equ
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b == a);
+} break;
+case UXN_OPC(0x09): { // neg
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b != a);
+} break;
+case UXN_OPC(0x0A): { // gth
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b > a);
+} break;
+case UXN_OPC(0x0B): { // lth
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b < a);
+} break;
+case UXN_OPC(0x0C): { // jmp
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        u->ram.ptr += (Sint8)a;
+} break;
+case UXN_OPC(0x0D): { // jnz
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        if (pop8(UXN_SRC))
+                u->ram.ptr += (Sint8)a;
+} break;
+case UXN_OPC(0x0E): { // jsr
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        push16(UXN_DST, u->ram.ptr);
+        u->ram.ptr += (Sint8)a;
+} break;
+case UXN_OPC(0x0F): { // sth
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        push8(UXN_DST, a);
+} break;
+case UXN_OPC(0x10): { // pek
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        push8(UXN_SRC, mempeek8(u->ram.dat, a));
+} break;
+case UXN_OPC(0x11): { // pok
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        mempoke8(u->ram.dat, a, b);
+} break;
+case UXN_OPC(0x12): { // ldr
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        push8(UXN_SRC, mempeek8(u->ram.dat, u->ram.ptr + (Sint8)a));
+} break;
+case UXN_OPC(0x13): { // str
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        mempoke8(u->ram.dat, u->ram.ptr + (Sint8)a, b);
+} break;
+case UXN_OPC(0x14): { // lda
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        push8(UXN_SRC, mempeek8(u->ram.dat, a));
+} break;
+case UXN_OPC(0x15): { // sta
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        mempoke8(u->ram.dat, a, b);
+} break;
+case UXN_OPC(0x16): { // dei
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        push8(UXN_SRC, devpeek8(&u->dev[a >> 4], a));
+} break;
+case UXN_OPC(0x17): { // deo
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        devpoke8(&u->dev[a >> 4], a, b);
+} break;
+case UXN_OPC(0x18): { // add
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b + a);
+} break;
+case UXN_OPC(0x19): { // sub
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b - a);
+} break;
+case UXN_OPC(0x1A): { // mul
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b * a);
+} break;
+case UXN_OPC(0x1B): { // div
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b / a);
+} break;
+case UXN_OPC(0x1C): { // and
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b & a);
+} break;
+case UXN_OPC(0x1D): { // ora
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b | a);
+} break;
+case UXN_OPC(0x1E): { // eor
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b ^ a);
+} break;
+case UXN_OPC(0x1F): { // sft
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint8 b = pop8(UXN_SRC);
+        push8(UXN_SRC, b >> (a & 0x07) << ((a & 0x70) >> 4));
+} break;
+
+/* 16-BIT OPCODES */
+
+case UXN_OPC(0x21): { // lit
+        push16(UXN_SRC, mempeek16(u->ram.dat, u->ram.ptr));
+        u->ram.ptr += 2;
+} break;
+case UXN_OPC(0x23): { // pop
+        UXN_KEEP_SYNC;
+        pop16(UXN_SRC);
+} break;
+case UXN_OPC(0x24): { // dup
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        push16(UXN_SRC, a);
+        push16(UXN_SRC, a);
+} break;
+case UXN_OPC(0x25): { // swp
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push16(UXN_SRC, a);
+        push16(UXN_SRC, b);
+} break;
+case UXN_OPC(0x26): { // ovr
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push16(UXN_SRC, b);
+        push16(UXN_SRC, a);
+        push16(UXN_SRC, b);
+} break;
+case UXN_OPC(0x27): { // rot
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        Uint16 c = pop16(UXN_SRC);
+        push16(UXN_SRC, b);
+        push16(UXN_SRC, a);
+        push16(UXN_SRC, c);
+} break;
+case UXN_OPC(0x28): { // equ
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push8(UXN_SRC, b == a);
+} break;
+case UXN_OPC(0x29): { // neg
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push8(UXN_SRC, b != a);
+} break;
+case UXN_OPC(0x2A): { // gth
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push8(UXN_SRC, b > a);
+} break;
+case UXN_OPC(0x2B): { // lth
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push8(UXN_SRC, b < a);
+} break;
+case UXN_OPC(0x2C): { // jmp
+        UXN_KEEP_SYNC;
+        u->ram.ptr = pop16(UXN_SRC);
+} break;
+case UXN_OPC(0x2D): { // jnz
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        if (pop8(UXN_SRC))
+                u->ram.ptr = a;
+} break;
+case UXN_OPC(0x2E): { // jsr
+        UXN_KEEP_SYNC;
+        push16(UXN_DST, u->ram.ptr);
+        u->ram.ptr = pop16(UXN_SRC);
+} break;
+case UXN_OPC(0x2F): { // sth
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        push16(UXN_DST, a);
+} break;
+case UXN_OPC(0x30): { // pek
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        push16(UXN_SRC, mempeek16(u->ram.dat, a));
+} break;
+case UXN_OPC(0x31): { // pok
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        mempoke16(u->ram.dat, a, b);
+} break;
+case UXN_OPC(0x32): { // ldr
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        push16(UXN_SRC, mempeek16(u->ram.dat, u->ram.ptr + (Sint8)a));
+} break;
+case UXN_OPC(0x33): { // str
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        mempoke16(u->ram.dat, u->ram.ptr + (Sint8)a, b);
+} break;
+case UXN_OPC(0x34): { // lda
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        push16(UXN_SRC, mempeek16(u->ram.dat, a));
+} break;
+case UXN_OPC(0x35): { // sta
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        mempoke16(u->ram.dat, a, b);
+} break;
+case UXN_OPC(0x36): { // dei
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        push16(UXN_SRC, devpeek16(&u->dev[a >> 4], a));
+} break;
+case UXN_OPC(0x37): { // deo
+        UXN_KEEP_SYNC;
+        Uint8 a = pop8(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        devpoke16(&u->dev[a >> 4], a, b);
+} break;
+case UXN_OPC(0x38): { // add
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push16(UXN_SRC, b + a);
+} break;
+case UXN_OPC(0x39): { // sub
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push16(UXN_SRC, b - a);
+} break;
+case UXN_OPC(0x3A): { // mul
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push16(UXN_SRC, b * a);
+} break;
+case UXN_OPC(0x3B): { // div
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push16(UXN_SRC, b / a);
+} break;
+case UXN_OPC(0x3C): { // and
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push16(UXN_SRC, b & a);
+} break;
+case UXN_OPC(0x3D): { // ora
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push16(UXN_SRC, b | a);
+} break;
+case UXN_OPC(0x3E): { // eor
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push16(UXN_SRC, b ^ a);
+} break;
+case UXN_OPC(0x3F): { // sft
+        UXN_KEEP_SYNC;
+        Uint16 a = pop16(UXN_SRC);
+        Uint16 b = pop16(UXN_SRC);
+        push16(UXN_SRC, b >> (a & 0x000f) << ((a & 0x00f0) >> 4));
+} break;