Merge pull request #421 from negativeExponent/lightrec_update

Update lightrec to latest upstream

27 files changed, 719 insertions, 249 deletions

diff --git a/Makefile b/Makefile
index 9866050..1496f4e 100644
--- a/Makefile
+++ b/Makefile
@@ -97,7 +97,8 @@ OBJS += deps/lightning/lib/jit_disasm.o \
 		deps/lightrec/memmanager.o \
 		deps/lightrec/optimizer.o \
 		deps/lightrec/regcache.o \
-		deps/lightrec/recompiler.o
+		deps/lightrec/recompiler.o \
+		deps/lightrec/reaper.o
 ifeq ($(MMAP_WIN32),1)
 CFLAGS += -Ideps/mman
 OBJS += deps/mman/mman.o
diff --git a/deps/lightrec/.gitrepo b/deps/lightrec/.gitrepo
index 871f638..0dbefe8 100644
--- a/deps/lightrec/.gitrepo
+++ b/deps/lightrec/.gitrepo
@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/pcercuei/lightrec.git
 	branch = master
-	commit = 6c69e104d0827e45b8c094d6a61f95c96e9efb15
-	parent = b7ee664796db949b417754d11d4ae405cf5144a5
+	commit = 2081869a00371dac285836fb950f8cd0c26b55b9
+	parent = 5c00ea32a0eab812299b08acd14c25bf6ba4ca7a
 	method = merge
 	cmdver = 0.4.1
diff --git a/deps/lightrec/CMakeLists.txt b/deps/lightrec/CMakeLists.txt
index 6ac5cd4..c58dac5 100644
--- a/deps/lightrec/CMakeLists.txt
+++ b/deps/lightrec/CMakeLists.txt
@@ -53,7 +53,7 @@ option(ENABLE_FIRST_PASS "Run the interpreter as first-pass optimization" ON)
 
 option(ENABLE_THREADED_COMPILER "Enable threaded compiler" ON)
 if (ENABLE_THREADED_COMPILER)
-	list(APPEND LIGHTREC_SOURCES recompiler.c)
+	list(APPEND LIGHTREC_SOURCES recompiler.c reaper.c)
 
 	if (NOT ENABLE_FIRST_PASS)
 		message(SEND_ERROR "Threaded compiler requires first-pass optimization")
diff --git a/deps/lightrec/README b/deps/lightrec/README
deleted file mode 100644
index 5bc4627..0000000
--- a/deps/lightrec/README
+++ /dev/null
@@ -1 +0,0 @@
-LightRec is my attempt at creating a dynamic recompiler for MIPS and powered by GNU Lightning.
diff --git a/deps/lightrec/README.md b/deps/lightrec/README.md
new file mode 100644
index 0000000..40ecc8f
--- /dev/null
+++ b/deps/lightrec/README.md
@@ -0,0 +1,53 @@
+
+# Lightrec
+
+Lightrec is a MIPS-to-everything dynamic recompiler for
+PlayStation emulators, using
+[GNU Lightning](https://www.gnu.org/software/lightning/)
+as the code emitter.
+
+As such, in theory it should be able to run on every CPU that Lightning
+can generate code for; including, but not limited to, __x86__, __x86_64__,
+__ARM__, __Aarch64__, __MIPS__, __PowerPC__ and __Risc-V__.
+
+## Features
+
+* __High-level optimizations__.  The MIPS code is first pre-compiled into
+a form of Intermediate Representation (IR).
+Basically, just a single-linked list of structures representing the
+instructions. On that list, several optimization steps are performed:
+instructions are modified, reordered, tagged; new meta-instructions
+can be added, for instance to tell the code generator that a certain
+register won't be used anymore.
+
+* __Lazy compilation__.
+If Lightrec detects a block of code that would be very hard to
+compile properly (e.g. a branch with a branch in its delay slot),
+the block is marked as not compilable, and will always be emulated
+with the built-in interpreter. This allows to keep the code emitter
+simple and easy to understand.
+
+* __Run-time profiling__.
+The generated code will gather run-time information about the I/O access
+(whether they hit RAM, or hardware registers).
+The code generator will then use this information to generate direct
+read/writes to the emulated memories, instead of jumping to C for
+every call.
+
+* __Threaded compilation__.
+When entering a loading zone, where a lot of code has to be compiled,
+we don't want the compilation process to slow down the pace of emulation.
+To avoid that, the code compiler optionally runs on a thread, and the
+main loop will emulate the blocks that have not been compiled yet with
+the interpreter. This helps to drastically reduce the stutter that
+typically happens when a lot of new code is run.
+
+## Emulators
+
+Lightrec has been ported to the following emulators:
+
+* [__PCSX-ReArmed__ (my own fork)](https://github.com/pcercuei/pcsx_rearmed)
+
+* [__pcsx4all__ (my own fork)](https://github.com/pcercuei/pcsx4all)
+
+* [__Beetle__ (libretro)](https://github.com/libretro/beetle-psx-libretro/)
\ No newline at end of file
diff --git a/deps/lightrec/blockcache.c b/deps/lightrec/blockcache.c
index 833a8e1..4263431 100644
--- a/deps/lightrec/blockcache.c
+++ b/deps/lightrec/blockcache.c
@@ -60,12 +60,6 @@ void remove_from_code_lut(struct blockcache *cache, struct block *block)
 
 }
 
-void lightrec_mark_for_recompilation(struct blockcache *cache,
-				     struct block *block)
-{
-	block->flags |= BLOCK_SHOULD_RECOMPILE;
-}
-
 void lightrec_register_block(struct blockcache *cache, struct block *block)
 {
 	u32 pc = kunseg(block->pc);
@@ -85,8 +79,6 @@ void lightrec_unregister_block(struct blockcache *cache, struct block *block)
 	u32 pc = kunseg(block->pc);
 	struct block *old = cache->lut[(pc >> 2) & (LUT_SIZE - 1)];
 
-	remove_from_code_lut(cache, block);
-
 	if (old == block) {
 		cache->lut[(pc >> 2) & (LUT_SIZE - 1)] = old->next;
 		return;
diff --git a/deps/lightrec/blockcache.h b/deps/lightrec/blockcache.h
index 0c57ffc..ff63651 100644
--- a/deps/lightrec/blockcache.h
+++ b/deps/lightrec/blockcache.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Paul Cercueil <paul@crapouillou.net>
+ * Copyright (C) 2014-2020 Paul Cercueil <paul@crapouillou.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -29,7 +29,4 @@ void lightrec_free_block_cache(struct blockcache *cache);
 u32 lightrec_calculate_block_hash(const struct block *block);
 _Bool lightrec_block_is_outdated(struct block *block);
 
-void lightrec_mark_for_recompilation(struct blockcache *cache,
-				     struct block *block);
-
 #endif /* __BLOCKCACHE_H__ */
diff --git a/deps/lightrec/config.h b/deps/lightrec/config.h
index 64c6a3f..b72ae10 100644
--- a/deps/lightrec/config.h
+++ b/deps/lightrec/config.h
@@ -21,4 +21,3 @@
 #define ENABLE_TINYMM 0
 
 #endif /* __LIGHTREC_CONFIG_H__ */
-
diff --git a/deps/lightrec/debug.h b/deps/lightrec/debug.h
index 4048d43..4facc22 100644
--- a/deps/lightrec/debug.h
+++ b/deps/lightrec/debug.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Paul Cercueil <paul@crapouillou.net>
+ * Copyright (C) 2014-2020 Paul Cercueil <paul@crapouillou.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/deps/lightrec/disassembler.h b/deps/lightrec/disassembler.h
index e4c4403..249d094 100644
--- a/deps/lightrec/disassembler.h
+++ b/deps/lightrec/disassembler.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Paul Cercueil <paul@crapouillou.net>
+ * Copyright (C) 2014-2020 Paul Cercueil <paul@crapouillou.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/deps/lightrec/emitter.c b/deps/lightrec/emitter.c
index b09dc94..206a45c 100644
--- a/deps/lightrec/emitter.c
+++ b/deps/lightrec/emitter.c
@@ -1250,7 +1250,8 @@ static void rec_mtc(const struct block *block, const struct opcode *op, u32 pc)
 
 	lightrec_regcache_mark_live(reg_cache, _jit);
 
-	if (op->i.op == OP_CP0 && (op->r.rd == 12 || op->r.rd == 13))
+	if (op->i.op == OP_CP0 && !(op->flags & LIGHTREC_NO_DS) &&
+	    (op->r.rd == 12 || op->r.rd == 13))
 		lightrec_emit_end_of_block(block, op, pc, -1, pc + 4, 0, 0, true);
 }
 
@@ -1427,7 +1428,7 @@ static void rec_meta_sync(const struct block *block,
 		 op->offset << 2);
 	target = &state->targets[state->nb_targets++];
 	target->offset = op->offset;
-	target->label = jit_label();
+	target->label = jit_indirect();
 }
 
 static const lightrec_rec_func_t rec_standard[64] = {
diff --git a/deps/lightrec/emitter.h b/deps/lightrec/emitter.h
index 57ededf..ec3fc78 100644
--- a/deps/lightrec/emitter.h
+++ b/deps/lightrec/emitter.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Paul Cercueil <paul@crapouillou.net>
+ * Copyright (C) 2014-2020 Paul Cercueil <paul@crapouillou.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/deps/lightrec/interpreter.c b/deps/lightrec/interpreter.c
index acc41ea..f586685 100644
--- a/deps/lightrec/interpreter.c
+++ b/deps/lightrec/interpreter.c
@@ -150,8 +150,8 @@ static u32 int_delay_slot(struct interpreter *inter, u32 pc, bool branch)
 		 * but on branch boundaries, we need to adjust the return
 		 * address so that the GTE opcode is effectively executed.
 		 */
-		cause = (*state->ops.cop0_ops.cfc)(state, 13);
-		epc = (*state->ops.cop0_ops.cfc)(state, 14);
+		cause = (*state->ops.cop0_ops.cfc)(state, op->c.opcode, 13);
+		epc = (*state->ops.cop0_ops.cfc)(state, op->c.opcode, 14);
 
 		if (!(cause & 0x7c) && epc == pc - 4)
 			pc -= 4;
@@ -218,6 +218,8 @@ static u32 int_delay_slot(struct interpreter *inter, u32 pc, bool branch)
 			branch_taken = is_branch_taken(reg_cache, op_next);
 			pr_debug("Target of impossible branch is a branch, "
 				 "%staken.\n", branch_taken ? "" : "not ");
+			inter->cycles += lightrec_cycles_of_opcode(op_next);
+			old_rs = reg_cache[op_next.r.rs];
 		} else {
 			new_op.c = op_next;
 			new_op.flags = 0;
@@ -248,16 +250,24 @@ static u32 int_delay_slot(struct interpreter *inter, u32 pc, bool branch)
 		new_rt = reg_cache[op->r.rt];
 
 	/* Execute delay slot opcode */
-	if (branch_at_addr)
-		ds_next_pc = int_branch(&inter2, pc, op_next, branch_taken);
-	else
-		ds_next_pc = (*int_standard[inter2.op->i.op])(&inter2);
+	ds_next_pc = (*int_standard[inter2.op->i.op])(&inter2);
+
+	if (branch_at_addr) {
+		if (op_next.i.op == OP_SPECIAL)
+			/* TODO: Handle JALR setting $ra */
+			ds_next_pc = old_rs;
+		else if (op_next.i.op == OP_J || op_next.i.op == OP_JAL)
+			/* TODO: Handle JAL setting $ra */
+			ds_next_pc = (pc & 0xf0000000) | (op_next.j.imm << 2);
+		else
+			ds_next_pc = pc + 4 + ((s16)op_next.i.imm << 2);
+	}
 
 	if (branch_at_addr && !branch_taken) {
 		/* If the branch at the target of the branch opcode is not
 		 * taken, we jump to its delay slot */
 		next_pc = pc + sizeof(u32);
-	} else if (!branch && branch_in_ds) {
+	} else if (branch_at_addr || (!branch && branch_in_ds)) {
 		next_pc = ds_next_pc;
 	}
 
@@ -475,7 +485,8 @@ static u32 int_ctc(struct interpreter *inter)
 	/* If we have a MTC0 or CTC0 to CP0 register 12 (Status) or 13 (Cause),
 	 * return early so that the emulator will be able to check software
 	 * interrupt status. */
-	if (op->i.op == OP_CP0 && (op->r.rd == 12 || op->r.rd == 13))
+	if (!(inter->op->flags & LIGHTREC_NO_DS) &&
+	    op->i.op == OP_CP0 && (op->r.rd == 12 || op->r.rd == 13))
 		return inter->block->pc + (op->offset + 1) * sizeof(u32);
 	else
 		return jump_next(inter);
@@ -487,13 +498,13 @@ static u32 int_cp0_RFE(struct interpreter *inter)
 	u32 status;
 
 	/* Read CP0 Status register (r12) */
-	status = state->ops.cop0_ops.mfc(state, 12);
+	status = state->ops.cop0_ops.mfc(state, inter->op->c.opcode, 12);
 
 	/* Switch the bits */
 	status = ((status & 0x3c) >> 2) | (status & ~0xf);
 
 	/* Write it back */
-	state->ops.cop0_ops.ctc(state, 12, status);
+	state->ops.cop0_ops.ctc(state, inter->op->c.opcode, 12, status);
 
 	return jump_next(inter);
 }
diff --git a/deps/lightrec/interpreter.h b/deps/lightrec/interpreter.h
index d4177b3..2113779 100644
--- a/deps/lightrec/interpreter.h
+++ b/deps/lightrec/interpreter.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 Paul Cercueil <paul@crapouillou.net>
+ * Copyright (C) 2019-2020 Paul Cercueil <paul@crapouillou.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/deps/lightrec/lightrec-private.h b/deps/lightrec/lightrec-private.h
index 4c9c269..6304515 100644
--- a/deps/lightrec/lightrec-private.h
+++ b/deps/lightrec/lightrec-private.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2016 Paul Cercueil <paul@crapouillou.net>
+ * Copyright (C) 2016-2020 Paul Cercueil <paul@crapouillou.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -50,6 +50,7 @@
 #define BLOCK_NEVER_COMPILE	BIT(0)
 #define BLOCK_SHOULD_RECOMPILE	BIT(1)
 #define BLOCK_FULLY_TAGGED	BIT(2)
+#define BLOCK_IS_DEAD		BIT(3)
 
 #define RAM_SIZE	0x200000
 #define BIOS_SIZE	0x80000
@@ -66,6 +67,7 @@ struct recompiler;
 struct regcache;
 struct opcode;
 struct tinymm;
+struct reaper;
 
 struct block {
 	jit_state_t *_jit;
@@ -115,9 +117,11 @@ struct lightrec_state {
 	struct blockcache *block_cache;
 	struct regcache *reg_cache;
 	struct recompiler *rec;
+	struct reaper *reaper;
 	void (*eob_wrapper_func)(void);
 	void (*get_next_block)(void);
 	struct lightrec_ops ops;
+	unsigned int nb_precompile;
 	unsigned int cycles;
 	unsigned int nb_maps;
 	const struct lightrec_mem_map *maps;
diff --git a/deps/lightrec/lightrec.c b/deps/lightrec/lightrec.c
index 47c49c8..7fdf74a 100644
--- a/deps/lightrec/lightrec.c
+++ b/deps/lightrec/lightrec.c
@@ -20,6 +20,7 @@
 #include "interpreter.h"
 #include "lightrec.h"
 #include "memmanager.h"
+#include "reaper.h"
 #include "recompiler.h"
 #include "regcache.h"
 #include "optimizer.h"
@@ -43,6 +44,60 @@
 static struct block * lightrec_precompile_block(struct lightrec_state *state,
 						u32 pc);
 
+static void lightrec_default_sb(struct lightrec_state *state, u32 opcode,
+				void *host, u32 addr, u8 data)
+{
+	*(u8 *)host = data;
+
+	if (!state->invalidate_from_dma_only)
+		lightrec_invalidate(state, addr, 1);
+}
+
+static void lightrec_default_sh(struct lightrec_state *state, u32 opcode,
+				void *host, u32 addr, u16 data)
+{
+	*(u16 *)host = HTOLE16(data);
+
+	if (!state->invalidate_from_dma_only)
+		lightrec_invalidate(state, addr, 2);
+}
+
+static void lightrec_default_sw(struct lightrec_state *state, u32 opcode,
+				void *host, u32 addr, u32 data)
+{
+	*(u32 *)host = HTOLE32(data);
+
+	if (!state->invalidate_from_dma_only)
+		lightrec_invalidate(state, addr, 4);
+}
+
+static u8 lightrec_default_lb(struct lightrec_state *state,
+			      u32 opcode, void *host, u32 addr)
+{
+	return *(u8 *)host;
+}
+
+static u16 lightrec_default_lh(struct lightrec_state *state,
+			       u32 opcode, void *host, u32 addr)
+{
+	return LE16TOH(*(u16 *)host);
+}
+
+static u32 lightrec_default_lw(struct lightrec_state *state,
+			       u32 opcode, void *host, u32 addr)
+{
+	return LE32TOH(*(u32 *)host);
+}
+
+static const struct lightrec_mem_map_ops lightrec_default_ops = {
+	.sb = lightrec_default_sb,
+	.sh = lightrec_default_sh,
+	.sw = lightrec_default_sw,
+	.lb = lightrec_default_lb,
+	.lh = lightrec_default_lh,
+	.lw = lightrec_default_lw,
+};
+
 static void __segfault_cb(struct lightrec_state *state, u32 addr)
 {
 	lightrec_set_exit_flags(state, LIGHTREC_EXIT_SEGFAULT);
@@ -50,33 +105,94 @@ static void __segfault_cb(struct lightrec_state *state, u32 addr)
 	       "load/store at address 0x%08x\n", addr);
 }
 
-static u32 lightrec_rw_ops(struct lightrec_state *state, union code op,
-		const struct lightrec_mem_map_ops *ops, u32 addr, u32 data)
+static void lightrec_swl(struct lightrec_state *state,
+			 const struct lightrec_mem_map_ops *ops,
+			 u32 opcode, void *host, u32 addr, u32 data)
 {
-	switch (op.i.op) {
-	case OP_SB:
-		ops->sb(state, addr, (u8) data);
-		return 0;
-	case OP_SH:
-		ops->sh(state, addr, (u16) data);
-		return 0;
-	case OP_SWL:
-	case OP_SWR:
-	case OP_SW:
-		ops->sw(state, addr, data);
-		return 0;
-	case OP_LB:
-		return (s32) (s8) ops->lb(state, addr);
-	case OP_LBU:
-		return ops->lb(state, addr);
-	case OP_LH:
-		return (s32) (s16) ops->lh(state, addr);
-	case OP_LHU:
-		return ops->lh(state, addr);
-	case OP_LW:
-	default:
-		return ops->lw(state, addr);
-	}
+	unsigned int shift = addr & 0x3;
+	unsigned int mask = GENMASK(31, (shift + 1) * 8);
+	u32 old_data;
+
+	/* Align to 32 bits */
+	addr &= ~3;
+	host = (void *)((uintptr_t)host & ~3);
+
+	old_data = ops->lw(state, opcode, host, addr);
+
+	data = (data >> ((3 - shift) * 8)) | (old_data & mask);
+
+	ops->sw(state, opcode, host, addr, data);
+}
+
+static void lightrec_swr(struct lightrec_state *state,
+			 const struct lightrec_mem_map_ops *ops,
+			 u32 opcode, void *host, u32 addr, u32 data)
+{
+	unsigned int shift = addr & 0x3;
+	unsigned int mask = (1 << (shift * 8)) - 1;
+	u32 old_data;
+
+	/* Align to 32 bits */
+	addr &= ~3;
+	host = (void *)((uintptr_t)host & ~3);
+
+	old_data = ops->lw(state, opcode, host, addr);
+
+	data = (data << (shift * 8)) | (old_data & mask);
+
+	ops->sw(state, opcode, host, addr, data);
+}
+
+static void lightrec_swc2(struct lightrec_state *state, union code op,
+			  const struct lightrec_mem_map_ops *ops,
+			  void *host, u32 addr)
+{
+	u32 data = state->ops.cop2_ops.mfc(state, op.opcode, op.i.rt);
+
+	ops->sw(state, op.opcode, host, addr, data);
+}
+
+static u32 lightrec_lwl(struct lightrec_state *state,
+			const struct lightrec_mem_map_ops *ops,
+			u32 opcode, void *host, u32 addr, u32 data)
+{
+	unsigned int shift = addr & 0x3;
+	unsigned int mask = (1 << (24 - shift * 8)) - 1;
+	u32 old_data;
+
+	/* Align to 32 bits */
+	addr &= ~3;
+	host = (void *)((uintptr_t)host & ~3);
+
+	old_data = ops->lw(state, opcode, host, addr);
+
+	return (data & mask) | (old_data << (24 - shift * 8));
+}
+
+static u32 lightrec_lwr(struct lightrec_state *state,
+			const struct lightrec_mem_map_ops *ops,
+			u32 opcode, void *host, u32 addr, u32 data)
+{
+	unsigned int shift = addr & 0x3;
+	unsigned int mask = GENMASK(31, 32 - shift * 8);
+	u32 old_data;
+
+	/* Align to 32 bits */
+	addr &= ~3;
+	host = (void *)((uintptr_t)host & ~3);
+
+	old_data = ops->lw(state, opcode, host, addr);
+
+	return (data & mask) | (old_data >> (shift * 8));
+}
+
+static void lightrec_lwc2(struct lightrec_state *state, union code op,
+			  const struct lightrec_mem_map_ops *ops,
+			  void *host, u32 addr)
+{
+	u32 data = ops->lw(state, op.opcode, host, addr);
+
+	state->ops.cop2_ops.mtc(state, op.opcode, op.i.rt, data);
 }
 
 static void lightrec_invalidate_map(struct lightrec_state *state,
@@ -105,9 +221,9 @@ u32 lightrec_rw(struct lightrec_state *state, union code op,
 		u32 addr, u32 data, u16 *flags)
 {
 	const struct lightrec_mem_map *map;
-	u32 shift, mem_data, mask, pc;
-	uintptr_t new_addr;
-	u32 kaddr;
+	const struct lightrec_mem_map_ops *ops;
+	u32 kaddr, pc, opcode = op.opcode;
+	void *host;
 
 	addr += (s16) op.i.imm;
 	kaddr = kunseg(addr);
@@ -120,91 +236,60 @@ u32 lightrec_rw(struct lightrec_state *state, union code op,
 
 	pc = map->pc;
 
+	while (map->mirror_of)
+		map = map->mirror_of;
+
+	host = (void *)((uintptr_t)map->address + kaddr - pc);
+
 	if (unlikely(map->ops)) {
 		if (flags)
 			*flags |= LIGHTREC_HW_IO;
 
-		return lightrec_rw_ops(state, op, map->ops, addr, data);
-	}
-
-	while (map->mirror_of)
-		map = map->mirror_of;
-
-	if (flags)
-		*flags |= LIGHTREC_DIRECT_IO;
+		ops = map->ops;
+	} else {
+		if (flags)
+			*flags |= LIGHTREC_DIRECT_IO;
 
-	kaddr -= pc;
-	new_addr = (uintptr_t) map->address + kaddr;
+		ops = &lightrec_default_ops;
+	}
 
 	switch (op.i.op) {
 	case OP_SB:
-		*(u8 *) new_addr = (u8) data;
-		if (!state->invalidate_from_dma_only)
-			lightrec_invalidate_map(state, map, kaddr);
+		ops->sb(state, opcode, host, addr, (u8) data);
 		return 0;
 	case OP_SH:
-		*(u16 *) new_addr = HTOLE16((u16) data);
-		if (!state->invalidate_from_dma_only)
-			lightrec_invalidate_map(state, map, kaddr);
+		ops->sh(state, opcode, host, addr, (u16) data);
 		return 0;
 	case OP_SWL:
-		shift = kaddr & 3;
-		mem_data = LE32TOH(*(u32 *)(new_addr & ~3));
-		mask = GENMASK(31, (shift + 1) * 8);
-
-		*(u32 *)(new_addr & ~3) = HTOLE32((data >> ((3 - shift) * 8))
-						  | (mem_data & mask));
-		if (!state->invalidate_from_dma_only)
-			lightrec_invalidate_map(state, map, kaddr & ~0x3);
+		lightrec_swl(state, ops, opcode, host, addr, data);
 		return 0;
 	case OP_SWR:
-		shift = kaddr & 3;
-		mem_data = LE32TOH(*(u32 *)(new_addr & ~3));
-		mask = (1 << (shift * 8)) - 1;
-
-		*(u32 *)(new_addr & ~3) = HTOLE32((data << (shift * 8))
-						  | (mem_data & mask));
-		if (!state->invalidate_from_dma_only)
-			lightrec_invalidate_map(state, map, kaddr & ~0x3);
+		lightrec_swr(state, ops, opcode, host, addr, data);
 		return 0;
 	case OP_SW:
-		*(u32 *) new_addr = HTOLE32(data);
-		if (!state->invalidate_from_dma_only)
-			lightrec_invalidate_map(state, map, kaddr);
+		ops->sw(state, opcode, host, addr, data);
 		return 0;
 	case OP_SWC2:
-		*(u32 *) new_addr = HTOLE32(state->ops.cop2_ops.mfc(state,
-								    op.i.rt));
-		if (!state->invalidate_from_dma_only)
-			lightrec_invalidate_map(state, map, kaddr);
+		lightrec_swc2(state, op, ops, host, addr);
 		return 0;
 	case OP_LB:
-		return (s32) *(s8 *) new_addr;
+		return (s32) (s8) ops->lb(state, opcode, host, addr);
 	case OP_LBU:
-		return *(u8 *) new_addr;
+		return ops->lb(state, opcode, host, addr);
 	case OP_LH:
-		return (s32)(s16) LE16TOH(*(u16 *) new_addr);
+		return (s32) (s16) ops->lh(state, opcode, host, addr);
 	case OP_LHU:
-		return LE16TOH(*(u16 *) new_addr);
-	case OP_LWL:
-		shift = kaddr & 3;
-		mem_data = LE32TOH(*(u32 *)(new_addr & ~3));
-		mask = (1 << (24 - shift * 8)) - 1;
-
-		return (data & mask) | (mem_data << (24 - shift * 8));
-	case OP_LWR:
-		shift = kaddr & 3;
-		mem_data = LE32TOH(*(u32 *)(new_addr & ~3));
-		mask = GENMASK(31, 32 - shift * 8);
-
-		return (data & mask) | (mem_data >> (shift * 8));
+		return ops->lh(state, opcode, host, addr);
 	case OP_LWC2:
-		state->ops.cop2_ops.mtc(state, op.i.rt,
-					LE32TOH(*(u32 *) new_addr));
+		lightrec_lwc2(state, op, ops, host, addr);
 		return 0;
+	case OP_LWL:
+		return lightrec_lwl(state, ops, opcode, host, addr, data);
+	case OP_LWR:
+		return lightrec_lwr(state, ops, opcode, host, addr, data);
 	case OP_LW:
 	default:
-		return LE32TOH(*(u32 *) new_addr);
+		return ops->lw(state, opcode, host, addr);
 	}
 }
 
@@ -247,7 +332,7 @@ static void lightrec_rw_generic_cb(struct lightrec_state *state,
 			 "tagged - flag for recompilation\n",
 			 block->pc, op->offset << 2);
 
-		lightrec_mark_for_recompilation(state->block_cache, block);
+		block->flags |= BLOCK_SHOULD_RECOMPILE;
 	}
 }
 
@@ -255,7 +340,7 @@ u32 lightrec_mfc(struct lightrec_state *state, union code op)
 {
 	bool is_cfc = (op.i.op == OP_CP0 && op.r.rs == OP_CP0_CFC0) ||
 		      (op.i.op == OP_CP2 && op.r.rs == OP_CP2_BASIC_CFC2);
-	u32 (*func)(struct lightrec_state *, u8);
+	u32 (*func)(struct lightrec_state *, u32, u8);
 	const struct lightrec_cop_ops *ops;
 
 	if (op.i.op == OP_CP0)
@@ -268,7 +353,7 @@ u32 lightrec_mfc(struct lightrec_state *state, union code op)
 	else
 		func = ops->mfc;
 
-	return (*func)(state, op.r.rd);
+	return (*func)(state, op.opcode, op.r.rd);
 }
 
 static void lightrec_mfc_cb(struct lightrec_state *state, union code op)
@@ -283,7 +368,7 @@ void lightrec_mtc(struct lightrec_state *state, union code op, u32 data)
 {
 	bool is_ctc = (op.i.op == OP_CP0 && op.r.rs == OP_CP0_CTC0) ||
 		      (op.i.op == OP_CP2 && op.r.rs == OP_CP2_BASIC_CTC2);
-	void (*func)(struct lightrec_state *, u8, u32);
+	void (*func)(struct lightrec_state *, u32, u8, u32);
 	const struct lightrec_cop_ops *ops;
 
 	if (op.i.op == OP_CP0)
@@ -296,7 +381,7 @@ void lightrec_mtc(struct lightrec_state *state, union code op, u32 data)
 	else
 		func = ops->mtc;
 
-	(*func)(state, op.r.rd, data);
+	(*func)(state, op.opcode, op.r.rd, data);
 }
 
 static void lightrec_mtc_cb(struct lightrec_state *state, union code op)
@@ -309,13 +394,13 @@ static void lightrec_rfe_cb(struct lightrec_state *state, union code op)
 	u32 status;
 
 	/* Read CP0 Status register (r12) */
-	status = state->ops.cop0_ops.mfc(state, 12);
+	status = state->ops.cop0_ops.mfc(state, op.opcode, 12);
 
 	/* Switch the bits */
 	status = ((status & 0x3c) >> 2) | (status & ~0xf);
 
 	/* Write it back */
-	state->ops.cop0_ops.ctc(state, 12, status);
+	state->ops.cop0_ops.ctc(state, op.opcode, 12, status);
 }
 
 static void lightrec_cp_cb(struct lightrec_state *state, union code op)
@@ -353,6 +438,7 @@ struct block * lightrec_get_block(struct lightrec_state *state, u32 pc)
 			lightrec_recompiler_remove(state->rec, block);
 
 		lightrec_unregister_block(state->block_cache, block);
+		remove_from_code_lut(state->block_cache, block);
 		lightrec_free_block(block);
 		block = NULL;
 	}
@@ -387,22 +473,18 @@ static void * get_next_block_func(struct lightrec_state *state, u32 pc)
 		if (unlikely(!block))
 			return NULL;
 
-		should_recompile = block->flags & BLOCK_SHOULD_RECOMPILE;
+		should_recompile = block->flags & BLOCK_SHOULD_RECOMPILE &&
+			!(block->flags & BLOCK_IS_DEAD);
 
 		if (unlikely(should_recompile)) {
-			pr_debug("Block at PC 0x%08x should recompile"
-				 " - freeing old code\n", pc);
-
-			if (ENABLE_THREADED_COMPILER)
-				lightrec_recompiler_remove(state->rec, block);
+			pr_debug("Block at PC 0x%08x should recompile\n", pc);
 
-			remove_from_code_lut(state->block_cache, block);
 			lightrec_unregister(MEM_FOR_CODE, block->code_size);
-			if (block->_jit)
-				_jit_destroy_state(block->_jit);
-			block->_jit = NULL;
-			block->function = NULL;
-			block->flags &= ~BLOCK_SHOULD_RECOMPILE;
+
+			if (ENABLE_THREADED_COMPILER)
+				lightrec_recompiler_add(state->rec, block);
+			else
+				lightrec_compile_block(block);
 		}
 
 		if (ENABLE_THREADED_COMPILER && likely(!should_recompile))
@@ -787,6 +869,8 @@ static struct block * lightrec_precompile_block(struct lightrec_state *state,
 
 	block->hash = lightrec_calculate_block_hash(block);
 
+	pr_debug("Recompile count: %u\n", state->nb_precompile++);
+
 	return block;
 }
 
@@ -824,17 +908,32 @@ static bool lightrec_block_is_fully_tagged(struct block *block)
 	return true;
 }
 
+static void lightrec_reap_block(void *data)
+{
+	struct block *block = data;
+
+	pr_debug("Reap dead block at PC 0x%08x\n", block->pc);
+	lightrec_free_block(block);
+}
+
+static void lightrec_reap_jit(void *data)
+{
+	_jit_destroy_state(data);
+}
+
 int lightrec_compile_block(struct block *block)
 {
 	struct lightrec_state *state = block->state;
+	struct lightrec_branch_target *target;
 	bool op_list_freed = false, fully_tagged = false;
+	struct block *block2;
 	struct opcode *elm;
-	jit_state_t *_jit;
+	jit_state_t *_jit, *oldjit;
 	jit_node_t *start_of_block;
 	bool skip_next = false;
 	jit_word_t code_size;
 	unsigned int i, j;
-	u32 next_pc;
+	u32 next_pc, offset;
 
 	fully_tagged = lightrec_block_is_fully_tagged(block);
 	if (fully_tagged)
@@ -844,6 +943,7 @@ int lightrec_compile_block(struct block *block)
 	if (!_jit)
 		return -ENOMEM;
 
+	oldjit = block->_jit;
 	block->_jit = _jit;
 
 	lightrec_regcache_reset(state->reg_cache);
@@ -921,10 +1021,52 @@ int lightrec_compile_block(struct block *block)
 	jit_epilog();
 
 	block->function = jit_emit();
+	block->flags &= ~BLOCK_SHOULD_RECOMPILE;
 
 	/* Add compiled function to the LUT */
 	state->code_lut[lut_offset(block->pc)] = block->function;
 
+	/* Fill code LUT with the block's entry points */
+	for (i = 0; i < state->nb_targets; i++) {
+		target = &state->targets[i];
+
+		if (target->offset) {
+			offset = lut_offset(block->pc) + target->offset;
+			state->code_lut[offset] = jit_address(target->label);
+		}
+	}
+
+	/* Detect old blocks that have been covered by the new one */
+	for (i = 0; i < state->nb_targets; i++) {
+		target = &state->targets[i];
+
+		if (!target->offset)
+			continue;
+
+		offset = block->pc + target->offset * sizeof(u32);
+		block2 = lightrec_find_block(state->block_cache, offset);
+		if (block2) {
+			/* No need to check if block2 is compilable - it must
+			 * be, otherwise block wouldn't be compilable either */
+
+			block2->flags |= BLOCK_IS_DEAD;
+
+			pr_debug("Reap block 0x%08x as it's covered by block "
+				 "0x%08x\n", block2->pc, block->pc);
+
+			lightrec_unregister_block(state->block_cache, block2);
+
+			if (ENABLE_THREADED_COMPILER) {
+				lightrec_recompiler_remove(state->rec, block2);
+				lightrec_reaper_add(state->reaper,
+						    lightrec_reap_block,
+						    block2);
+			} else {
+				lightrec_free_block(block2);
+			}
+		}
+	}
+
 	jit_get_code(&code_size);
 	lightrec_register(MEM_FOR_CODE, code_size);
 
@@ -948,6 +1090,17 @@ int lightrec_compile_block(struct block *block)
 		block->opcode_list = NULL;
 	}
 
+	if (oldjit) {
+		pr_debug("Block 0x%08x recompiled, reaping old jit context.\n",
+			 block->pc);
+
+		if (ENABLE_THREADED_COMPILER)
+			lightrec_reaper_add(state->reaper,
+					    lightrec_reap_jit, oldjit);
+		else
+			_jit_destroy_state(oldjit);
+	}
+
 	return 0;
 }
 
@@ -974,6 +1127,9 @@ u32 lightrec_execute(struct lightrec_state *state, u32 pc, u32 target_cycle)
 		state->current_cycle = state->target_cycle - cycles_delta;
 	}
 
+	if (ENABLE_THREADED_COMPILER)
+		lightrec_reaper_reap(state->reaper);
+
 	return state->next_pc;
 }
 
@@ -1049,6 +1205,10 @@ struct lightrec_state * lightrec_init(char *argv0,
 		state->rec = lightrec_recompiler_init(state);
 		if (!state->rec)
 			goto err_free_reg_cache;
+
+		state->reaper = lightrec_reaper_init(state);
+		if (!state->reaper)
+			goto err_free_recompiler;
 	}
 
 	state->nb_maps = nb;
@@ -1058,7 +1218,7 @@ struct lightrec_state * lightrec_init(char *argv0,
 
 	state->dispatcher = generate_dispatcher(state);
 	if (!state->dispatcher)
-		goto err_free_recompiler;
+		goto err_free_reaper;
 
 	state->rw_generic_wrapper = generate_wrapper(state,
 						     lightrec_rw_generic_cb,
@@ -1137,6 +1297,9 @@ err_free_generic_rw_wrapper:
 	lightrec_free_block(state->rw_generic_wrapper);
 err_free_dispatcher:
 	lightrec_free_block(state->dispatcher);
+err_free_reaper:
+	if (ENABLE_THREADED_COMPILER)
+		lightrec_reaper_destroy(state->reaper);
 err_free_recompiler:
 	if (ENABLE_THREADED_COMPILER)
 		lightrec_free_recompiler(state->rec);
@@ -1159,8 +1322,10 @@ err_finish_jit:
 
 void lightrec_destroy(struct lightrec_state *state)
 {
-	if (ENABLE_THREADED_COMPILER)
+	if (ENABLE_THREADED_COMPILER) {
 		lightrec_free_recompiler(state->rec);
+		lightrec_reaper_destroy(state->reaper);
+	}
 
 	lightrec_free_regcache(state->reg_cache);
 	lightrec_free_block_cache(state->block_cache);
diff --git a/deps/lightrec/lightrec.h b/deps/lightrec/lightrec.h
index d3d896c..d0793c0 100644
--- a/deps/lightrec/lightrec.h
+++ b/deps/lightrec/lightrec.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2016 Paul Cercueil <paul@crapouillou.net>
+ * Copyright (C) 2016-2020 Paul Cercueil <paul@crapouillou.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -78,12 +78,15 @@ enum mem_type {
 };
 
 struct lightrec_mem_map_ops {
-	void (*sb)(struct lightrec_state *, u32 addr, u8 data);
-	void (*sh)(struct lightrec_state *, u32 addr, u16 data);
-	void (*sw)(struct lightrec_state *, u32 addr, u32 data);
-	u8 (*lb)(struct lightrec_state *, u32 addr);
-	u16 (*lh)(struct lightrec_state *, u32 addr);
-	u32 (*lw)(struct lightrec_state *, u32 addr);
+	void (*sb)(struct lightrec_state *, u32 opcode,
+		   void *host, u32 addr, u8 data);
+	void (*sh)(struct lightrec_state *, u32 opcode,
+		   void *host, u32 addr, u16 data);
+	void (*sw)(struct lightrec_state *, u32 opcode,
+		   void *host, u32 addr, u32 data);
+	u8 (*lb)(struct lightrec_state *, u32 opcode, void *host, u32 addr);
+	u16 (*lh)(struct lightrec_state *, u32 opcode, void *host, u32 addr);
+	u32 (*lw)(struct lightrec_state *, u32 opcode, void *host, u32 addr);
 };
 
 struct lightrec_mem_map {
@@ -95,11 +98,11 @@ struct lightrec_mem_map {
 };
 
 struct lightrec_cop_ops {
-	u32 (*mfc)(struct lightrec_state *state, u8 reg);
-	u32 (*cfc)(struct lightrec_state *state, u8 reg);
-	void (*mtc)(struct lightrec_state *state, u8 reg, u32 value);
-	void (*ctc)(struct lightrec_state *state, u8 reg, u32 value);
-	void (*op)(struct lightrec_state *state, u32 opcode);
+	u32 (*mfc)(struct lightrec_state *state, u32 op, u8 reg);
+	u32 (*cfc)(struct lightrec_state *state, u32 op, u8 reg);
+	void (*mtc)(struct lightrec_state *state, u32 op, u8 reg, u32 value);
+	void (*ctc)(struct lightrec_state *state, u32 op, u8 reg, u32 value);
+	void (*op)(struct lightrec_state *state, u32 op);
 };
 
 struct lightrec_ops {
diff --git a/deps/lightrec/memmanager.h b/deps/lightrec/memmanager.h
index 956e7c7..bd5028d 100644
--- a/deps/lightrec/memmanager.h
+++ b/deps/lightrec/memmanager.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 Paul Cercueil <paul@crapouillou.net>
+ * Copyright (C) 2019-2020 Paul Cercueil <paul@crapouillou.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/deps/lightrec/optimizer.c b/deps/lightrec/optimizer.c
index 92b4daa..cf431f2 100644
--- a/deps/lightrec/optimizer.c
+++ b/deps/lightrec/optimizer.c
@@ -675,7 +675,7 @@ static int lightrec_switch_delay_slots(struct block *block)
 		list->c = next_op;
 		list->next->c = op;
 		list->next->flags = list->flags | LIGHTREC_NO_DS;
-		list->flags = flags;
+		list->flags = flags | LIGHTREC_NO_DS;
 		list->offset++;
 		list->next->offset--;
 	}
@@ -877,11 +877,12 @@ static int lightrec_flag_stores(struct block *block)
 		case OP_SB:
 		case OP_SH:
 		case OP_SW:
-			/* Mark all store operations that target $sp, $gp, $k0
-			 * or $k1 as not requiring code invalidation. This is
-			 * based on the heuristic that stores using one of these
+			/* Mark all store operations that target $sp or $gp
+			 * as not requiring code invalidation. This is based
+			 * on the heuristic that stores using one of these
 			 * registers as address will never hit a code page. */
-			if (list->i.rs >= 26 && list->i.rs <= 29) {
+			if (list->i.rs >= 28 && list->i.rs <= 29 &&
+			    !block->state->maps[PSX_MAP_KERNEL_USER_RAM].ops) {
 				pr_debug("Flaging opcode 0x%08x as not requiring invalidation\n",
 					 list->opcode);
 				list->flags |= LIGHTREC_NO_INVALIDATE;
diff --git a/deps/lightrec/optimizer.h b/deps/lightrec/optimizer.h
index d8def69..84a8fc9 100644
--- a/deps/lightrec/optimizer.h
+++ b/deps/lightrec/optimizer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Paul Cercueil <paul@crapouillou.net>
+ * Copyright (C) 2014-2020 Paul Cercueil <paul@crapouillou.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/deps/lightrec/reaper.c b/deps/lightrec/reaper.c
new file mode 100644
index 0000000..377685c
--- /dev/null
+++ b/deps/lightrec/reaper.c
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2020 Paul Cercueil <paul@crapouillou.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ */
+
+#include "blockcache.h"
+#include "debug.h"
+#include "lightrec-private.h"
+#include "memmanager.h"
+#include "slist.h"
+#include "reaper.h"
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdbool.h>
+
+struct reaper_elm {
+	reap_func_t func;
+	void *data;
+	struct slist_elm slist;
+};
+
+struct reaper {
+	struct lightrec_state *state;
+	pthread_mutex_t mutex;
+	struct slist_elm reap_list;
+};
+
+struct reaper *lightrec_reaper_init(struct lightrec_state *state)
+{
+	struct reaper *reaper;
+	int ret;
+
+	reaper = lightrec_malloc(state, MEM_FOR_LIGHTREC, sizeof(*reaper));
+	if (!reaper) {
+		pr_err("Cannot create reaper: Out of memory\n");
+		return NULL;
+	}
+
+	reaper->state = state;
+	slist_init(&reaper->reap_list);
+
+	ret = pthread_mutex_init(&reaper->mutex, NULL);
+	if (ret) {
+		pr_err("Cannot init mutex variable: %d\n", ret);
+		lightrec_free(reaper->state, MEM_FOR_LIGHTREC,
+			      sizeof(*reaper), reaper);
+		return NULL;
+	}
+
+	return reaper;
+}
+
+void lightrec_reaper_destroy(struct reaper *reaper)
+{
+	pthread_mutex_destroy(&reaper->mutex);
+	lightrec_free(reaper->state, MEM_FOR_LIGHTREC, sizeof(*reaper), reaper);
+}
+
+int lightrec_reaper_add(struct reaper *reaper, reap_func_t f, void *data)
+{
+	struct reaper_elm *reaper_elm;
+	struct slist_elm *elm;
+	int ret = 0;
+
+	pthread_mutex_lock(&reaper->mutex);
+
+	for (elm = reaper->reap_list.next; elm; elm = elm->next) {
+		reaper_elm = container_of(elm, struct reaper_elm, slist);
+
+		if (reaper_elm->data == data)
+			goto out_unlock;
+	}
+
+	reaper_elm = lightrec_malloc(reaper->state, MEM_FOR_LIGHTREC,
+				     sizeof(*reaper_elm));
+	if (!reaper_elm) {
+		pr_err("Cannot add reaper entry: Out of memory\n");
+		ret = -ENOMEM;
+		goto out_unlock;
+	}
+
+	reaper_elm->func = f;
+	reaper_elm->data = data;
+	slist_append(&reaper->reap_list, &reaper_elm->slist);
+
+out_unlock:
+	pthread_mutex_unlock(&reaper->mutex);
+	return ret;
+}
+
+void lightrec_reaper_reap(struct reaper *reaper)
+{
+	struct reaper_elm *reaper_elm;
+	struct slist_elm *elm;
+
+	pthread_mutex_lock(&reaper->mutex);
+
+	while (!!(elm = slist_first(&reaper->reap_list))) {
+		slist_remove(&reaper->reap_list, elm);
+		pthread_mutex_unlock(&reaper->mutex);
+
+		reaper_elm = container_of(elm, struct reaper_elm, slist);
+
+		(*reaper_elm->func)(reaper_elm->data);
+
+		lightrec_free(reaper->state, MEM_FOR_LIGHTREC,
+			      sizeof(*reaper_elm), reaper_elm);
+
+		pthread_mutex_lock(&reaper->mutex);
+	}
+
+	pthread_mutex_unlock(&reaper->mutex);
+}
diff --git a/deps/lightrec/reaper.h b/deps/lightrec/reaper.h
new file mode 100644
index 0000000..0309b64
--- /dev/null
+++ b/deps/lightrec/reaper.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 Paul Cercueil <paul@crapouillou.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ */
+
+#ifndef __LIGHTREC_REAPER_H__
+#define __LIGHTREC_REAPER_H__
+
+struct lightrec_state;
+struct reaper;
+
+typedef void (*reap_func_t)(void *);
+
+struct reaper *lightrec_reaper_init(struct lightrec_state *state);
+void lightrec_reaper_destroy(struct reaper *reaper);
+
+int lightrec_reaper_add(struct reaper *reaper, reap_func_t f, void *data);
+void lightrec_reaper_reap(struct reaper *reaper);
+
+#endif /* __LIGHTREC_REAPER_H__ */
diff --git a/deps/lightrec/recompiler.c b/deps/lightrec/recompiler.c
index 379881a..e60889c 100644
--- a/deps/lightrec/recompiler.c
+++ b/deps/lightrec/recompiler.c
@@ -16,6 +16,7 @@
 #include "interpreter.h"
 #include "lightrec-private.h"
 #include "memmanager.h"
+#include "slist.h"
 
 #include <errno.h>
 #include <stdatomic.h>
@@ -25,7 +26,7 @@
 
 struct block_rec {
 	struct block *block;
-	struct block_rec *next;
+	struct slist_elm slist;
 };
 
 struct recompiler {
@@ -35,31 +36,19 @@ struct recompiler {
 	pthread_mutex_t mutex;
 	bool stop;
 	struct block *current_block;
-	struct block_rec *list;
+	struct slist_elm slist;
 };
 
-static void slist_remove(struct recompiler *rec, struct block_rec *elm)
-{
-	struct block_rec *prev;
-
-	if (rec->list == elm) {
-		rec->list = elm->next;
-	} else {
-		for (prev = rec->list; prev && prev->next != elm; )
-			prev = prev->next;
-		if (prev)
-			prev->next = elm->next;
-	}
-}
-
 static void lightrec_compile_list(struct recompiler *rec)
 {
-	struct block_rec *next;
+	struct block_rec *block_rec;
+	struct slist_elm *next;
 	struct block *block;
 	int ret;
 
-	while (!!(next = rec->list)) {
-		block = next->block;
+	while (!!(next = slist_first(&rec->slist))) {
+		block_rec = container_of(next, struct block_rec, slist);
+		block = block_rec->block;
 		rec->current_block = block;
 
 		pthread_mutex_unlock(&rec->mutex);
@@ -72,9 +61,9 @@ static void lightrec_compile_list(struct recompiler *rec)
 
 		pthread_mutex_lock(&rec->mutex);
 
-		slist_remove(rec, next);
+		slist_remove(&rec->slist, next);
 		lightrec_free(rec->state, MEM_FOR_LIGHTREC,
-			      sizeof(*next), next);
+			      sizeof(*block_rec), block_rec);
 		pthread_cond_signal(&rec->cond);
 	}
 
@@ -87,19 +76,21 @@ static void * lightrec_recompiler_thd(void *d)
 
 	pthread_mutex_lock(&rec->mutex);
 
-	for (;;) {
+	do {
 		do {
 			pthread_cond_wait(&rec->cond, &rec->mutex);
 
-			if (rec->stop) {
-				pthread_mutex_unlock(&rec->mutex);
-				return NULL;
-			}
+			if (rec->stop)
+				goto out_unlock;
 
-		} while (!rec->list);
+		} while (slist_empty(&rec->slist));
 
 		lightrec_compile_list(rec);
-	}
+	} while (!rec->stop);
+
+out_unlock:
+	pthread_mutex_unlock(&rec->mutex);
+	return NULL;
 }
 
 struct recompiler *lightrec_recompiler_init(struct lightrec_state *state)
@@ -116,7 +107,7 @@ struct recompiler *lightrec_recompiler_init(struct lightrec_state *state)
 	rec->state = state;
 	rec->stop = false;
 	rec->current_block = NULL;
-	rec->list = NULL;
+	slist_init(&rec->slist);
 
 	ret = pthread_cond_init(&rec->cond, NULL);
 	if (ret) {
@@ -164,60 +155,77 @@ void lightrec_free_recompiler(struct recompiler *rec)
 
 int lightrec_recompiler_add(struct recompiler *rec, struct block *block)
 {
-	struct block_rec *block_rec, *prev;
+	struct slist_elm *elm, *prev;
+	struct block_rec *block_rec;
+	int ret = 0;
 
 	pthread_mutex_lock(&rec->mutex);
 
-	for (block_rec = rec->list, prev = NULL; block_rec;
-	     prev = block_rec, block_rec = block_rec->next) {
+	/* If the block is marked as dead, don't compile it, it will be removed
+	 * as soon as it's safe. */
+	if (block->flags & BLOCK_IS_DEAD)
+		goto out_unlock;
+
+	for (elm = slist_first(&rec->slist), prev = NULL; elm;
+	     prev = elm, elm = elm->next) {
+		block_rec = container_of(elm, struct block_rec, slist);
+
 		if (block_rec->block == block) {
 			/* The block to compile is already in the queue - bump
-			 * it to the top of the list */
-			if (prev) {
-				prev->next = block_rec->next;
-				block_rec->next = rec->list;
-				rec->list = block_rec;
+			 * it to the top of the list, unless the block is being
+			 * recompiled. */
+			if (prev && !(block->flags & BLOCK_SHOULD_RECOMPILE)) {
+				slist_remove_next(prev);
+				slist_append(&rec->slist, elm);
 			}
 
-			pthread_mutex_unlock(&rec->mutex);
-			return 0;
+			goto out_unlock;
 		}
 	}
 
 	/* By the time this function was called, the block has been recompiled
 	 * and ins't in the wait list anymore. Just return here. */
-	if (block->function) {
-		pthread_mutex_unlock(&rec->mutex);
-		return 0;
-	}
+	if (block->function && !(block->flags & BLOCK_SHOULD_RECOMPILE))
+		goto out_unlock;
 
 	block_rec = lightrec_malloc(rec->state, MEM_FOR_LIGHTREC,
 				    sizeof(*block_rec));
 	if (!block_rec) {
-		pthread_mutex_unlock(&rec->mutex);
-		return -ENOMEM;
+		ret = -ENOMEM;
+		goto out_unlock;
 	}
 
 	pr_debug("Adding block PC 0x%x to recompiler\n", block->pc);
 
 	block_rec->block = block;
-	block_rec->next = rec->list;
-	rec->list = block_rec;
+
+	elm = &rec->slist;
+
+	/* If the block is being recompiled, push it to the end of the queue;
+	 * otherwise push it to the front of the queue. */
+	if (block->flags & BLOCK_SHOULD_RECOMPILE)
+		for (; elm->next; elm = elm->next);
+
+	slist_append(elm, &block_rec->slist);
 
 	/* Signal the thread */
 	pthread_cond_signal(&rec->cond);
-	pthread_mutex_unlock(&rec->mutex);
 
-	return 0;
+out_unlock:
+	pthread_mutex_unlock(&rec->mutex);
+	return ret;
 }
 
 void lightrec_recompiler_remove(struct recompiler *rec, struct block *block)
 {
 	struct block_rec *block_rec;
+	struct slist_elm *elm;
 
 	pthread_mutex_lock(&rec->mutex);
 
-	for (block_rec = rec->list; block_rec; block_rec = block_rec->next) {
+	for (elm = slist_first(&rec->slist); elm; elm = elm->next) {
+		block_rec = container_of(elm, struct block_rec, slist);
+
 		if (block_rec->block == block) {
 			if (block == rec->current_block) {
 				/* Block is being recompiled - wait for
@@ -229,7 +237,7 @@ void lightrec_recompiler_remove(struct recompiler *rec, struct block *block)
 			} else {
 				/* Block is not yet being processed - remove it
 				 * from the list */
-				slist_remove(rec, block_rec);
+				slist_remove(&rec->slist, elm);
 				lightrec_free(rec->state, MEM_FOR_LIGHTREC,
 					      sizeof(*block_rec), block_rec);
 			}
diff --git a/deps/lightrec/recompiler.h b/deps/lightrec/recompiler.h
index 99e82aa..999a49f 100644
--- a/deps/lightrec/recompiler.h
+++ b/deps/lightrec/recompiler.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 Paul Cercueil <paul@crapouillou.net>
+ * Copyright (C) 2019-2020 Paul Cercueil <paul@crapouillou.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/deps/lightrec/regcache.h b/deps/lightrec/regcache.h
index 956cc3c..8678cc6 100644
--- a/deps/lightrec/regcache.h
+++ b/deps/lightrec/regcache.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Paul Cercueil <paul@crapouillou.net>
+ * Copyright (C) 2014-2020 Paul Cercueil <paul@crapouillou.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/deps/lightrec/slist.h b/deps/lightrec/slist.h
new file mode 100644
index 0000000..18195e8
--- /dev/null
+++ b/deps/lightrec/slist.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2020 Paul Cercueil <paul@crapouillou.net>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ */
+
+#ifndef __LIGHTREC_SLIST_H__
+#define __LIGHTREC_SLIST_H__
+
+#define container_of(ptr, type, member)	\
+	((type *)((void *)(ptr) - offsetof(type, member)))
+
+struct slist_elm {
+	struct slist_elm *next;
+};
+
+static inline void slist_init(struct slist_elm *head)
+{
+	head->next = NULL;
+}
+
+static inline struct slist_elm * slist_first(struct slist_elm *head)
+{
+	return head->next;
+}
+
+static inline _Bool slist_empty(const struct slist_elm *head)
+{
+	return head->next == NULL;
+}
+
+static inline void slist_remove_next(struct slist_elm *elm)
+{
+	if (elm->next)
+		elm->next = elm->next->next;
+}
+
+static inline void slist_remove(struct slist_elm *head, struct slist_elm *elm)
+{
+	struct slist_elm *prev;
+
+	if (head->next == elm) {
+		head->next = elm->next;
+	} else {
+		for (prev = head->next; prev && prev->next != elm; )
+			prev = prev->next;
+		if (prev)
+			slist_remove_next(prev);
+	}
+}
+
+static inline void slist_append(struct slist_elm *head, struct slist_elm *elm)
+{
+	elm->next = head->next;
+	head->next = elm;
+}
+
+#endif /* __LIGHTREC_SLIST_H__ */
diff --git a/libpcsxcore/lightrec/plugin.c b/libpcsxcore/lightrec/plugin.c
index 8c64c67..79bf021 100644
--- a/libpcsxcore/lightrec/plugin.c
+++ b/libpcsxcore/lightrec/plugin.c
@@ -42,6 +42,7 @@ static struct lightrec_state *lightrec_state;
 static char *name = "retroarch.exe";
 
 static bool use_lightrec_interpreter;
+static bool use_pcsx_interpreter;
 static bool lightrec_debug;
 static bool lightrec_very_debug;
 static u32 lightrec_begin_cycles;
@@ -111,7 +112,7 @@ static void (*cp2_ops[])(struct psxCP2Regs *) = {
 
 static char cache_buf[64 * 1024];
 
-static u32 cop0_mfc(struct lightrec_state *state, u8 reg)
+static u32 cop0_mfc(struct lightrec_state *state, u32 op, u8 reg)
 {
 	return psxRegs.CP0.r[reg];
 }
@@ -124,12 +125,12 @@ static u32 cop2_mfc_cfc(struct lightrec_state *state, u8 reg, bool cfc)
 		return MFC2(reg);
 }
 
-static u32 cop2_mfc(struct lightrec_state *state, u8 reg)
+static u32 cop2_mfc(struct lightrec_state *state, u32 op, u8 reg)
 {
 	return cop2_mfc_cfc(state, reg, false);
 }
 
-static u32 cop2_cfc(struct lightrec_state *state, u8 reg)
+static u32 cop2_cfc(struct lightrec_state *state, u32 op, u8 reg)
 {
 	return cop2_mfc_cfc(state, reg, true);
 }
@@ -176,22 +177,22 @@ static void cop2_mtc_ctc(struct lightrec_state *state,
 		MTC2(value, reg);
 }
 
-static void cop0_mtc(struct lightrec_state *state, u8 reg, u32 value)
+static void cop0_mtc(struct lightrec_state *state, u32 op, u8 reg, u32 value)
 {
 	cop0_mtc_ctc(state, reg, value, false);
 }
 
-static void cop0_ctc(struct lightrec_state *state, u8 reg, u32 value)
+static void cop0_ctc(struct lightrec_state *state, u32 op, u8 reg, u32 value)
 {
 	cop0_mtc_ctc(state, reg, value, true);
 }
 
-static void cop2_mtc(struct lightrec_state *state, u8 reg, u32 value)
+static void cop2_mtc(struct lightrec_state *state, u32 op, u8 reg, u32 value)
 {
 	cop2_mtc_ctc(state, reg, value, false);
 }
 
-static void cop2_ctc(struct lightrec_state *state, u8 reg, u32 value)
+static void cop2_ctc(struct lightrec_state *state, u32 op, u8 reg, u32 value)
 {
 	cop2_mtc_ctc(state, reg, value, true);
 }
@@ -211,7 +212,8 @@ static void cop2_op(struct lightrec_state *state, u32 func)
 		cp2_ops[func & 0x3f](&psxRegs.CP2);
 }
 
-static void hw_write_byte(struct lightrec_state *state, u32 mem, u8 val)
+static void hw_write_byte(struct lightrec_state *state,
+			  u32 op, void *host, u32 mem, u8 val)
 {
 	psxRegs.cycle = lightrec_current_cycle_count(state);
 
@@ -221,7 +223,8 @@ static void hw_write_byte(struct lightrec_state *state, u32 mem, u8 val)
 	lightrec_reset_cycle_count(state, psxRegs.cycle);
 }
 
-static void hw_write_half(struct lightrec_state *state, u32 mem, u16 val)
+static void hw_write_half(struct lightrec_state *state,
+			  u32 op, void *host, u32 mem, u16 val)
 {
 	psxRegs.cycle = lightrec_current_cycle_count(state);
 
@@ -231,7 +234,8 @@ static void hw_write_half(struct lightrec_state *state, u32 mem, u16 val)
 	lightrec_reset_cycle_count(state, psxRegs.cycle);
 }
 
-static void hw_write_word(struct lightrec_state *state, u32 mem, u32 val)
+static void hw_write_word(struct lightrec_state *state,
+			  u32 op, void *host, u32 mem, u32 val)
 {
 	psxRegs.cycle = lightrec_current_cycle_count(state);
 
@@ -241,7 +245,7 @@ static void hw_write_word(struct lightrec_state *state, u32 mem, u32 val)
 	lightrec_reset_cycle_count(state, psxRegs.cycle);
 }
 
-static u8 hw_read_byte(struct lightrec_state *state, u32 mem)
+static u8 hw_read_byte(struct lightrec_state *state, u32 op, void *host, u32 mem)
 {
 	u8 val;
 
@@ -254,7 +258,8 @@ static u8 hw_read_byte(struct lightrec_state *state, u32 mem)
 	return val;
 }
 
-static u16 hw_read_half(struct lightrec_state *state, u32 mem)
+static u16 hw_read_half(struct lightrec_state *state,
+			u32 op, void *host, u32 mem)
 {
 	u16 val;
 
@@ -267,7 +272,8 @@ static u16 hw_read_half(struct lightrec_state *state, u32 mem)
 	return val;
 }
 
-static u32 hw_read_word(struct lightrec_state *state, u32 mem)
+static u32 hw_read_word(struct lightrec_state *state,
+			u32 op, void *host, u32 mem)
 {
 	u32 val;
 
@@ -291,12 +297,14 @@ static struct lightrec_mem_map_ops hw_regs_ops = {
 
 static u32 cache_ctrl;
 
-static void cache_ctrl_write_word(struct lightrec_state *state, u32 mem, u32 val)
+static void cache_ctrl_write_word(struct lightrec_state *state,
+				  u32 op, void *host, u32 mem, u32 val)
 {
 	cache_ctrl = val;
 }
 
-static u32 cache_ctrl_read_word(struct lightrec_state *state, u32 mem)
+static u32 cache_ctrl_read_word(struct lightrec_state *state,
+				u32 op, void *host, u32 mem)
 {
 	return cache_ctrl;
 }
@@ -489,6 +497,9 @@ static void print_for_big_ass_debugger(void)
 	printf("\n");
 }
 
+
+extern void intExecuteBlock();
+
 static u32 old_cycle_counter;
 
 static void lightrec_plugin_execute_block(void)
@@ -496,27 +507,33 @@ static void lightrec_plugin_execute_block(void)
 	u32 old_pc = psxRegs.pc;
 	u32 flags;
 
-	lightrec_reset_cycle_count(lightrec_state, psxRegs.cycle);
-	lightrec_restore_registers(lightrec_state, psxRegs.GPR.r);
+	if (use_pcsx_interpreter) {
+		intExecuteBlock();
+	} else {
+		lightrec_reset_cycle_count(lightrec_state, psxRegs.cycle);
+		lightrec_restore_registers(lightrec_state, psxRegs.GPR.r);
 
-	if (use_lightrec_interpreter)
-		psxRegs.pc = lightrec_run_interpreter(lightrec_state, psxRegs.pc);
-	else
-		psxRegs.pc = lightrec_execute_one(lightrec_state, psxRegs.pc);
+		if (use_lightrec_interpreter)
+			psxRegs.pc = lightrec_run_interpreter(lightrec_state,
+							      psxRegs.pc);
+		else
+			psxRegs.pc = lightrec_execute_one(lightrec_state,
+							  psxRegs.pc);
 
-	psxRegs.cycle = lightrec_current_cycle_count(lightrec_state);
+		psxRegs.cycle = lightrec_current_cycle_count(lightrec_state);
 
-	lightrec_dump_registers(lightrec_state, psxRegs.GPR.r);
-	flags = lightrec_exit_flags(lightrec_state);
+		lightrec_dump_registers(lightrec_state, psxRegs.GPR.r);
+		flags = lightrec_exit_flags(lightrec_state);
 
-	if (flags & LIGHTREC_EXIT_SEGFAULT) {
-		fprintf(stderr, "Exiting at cycle 0x%08x\n",
-			psxRegs.cycle);
-		exit(1);
-	}
+		if (flags & LIGHTREC_EXIT_SEGFAULT) {
+			fprintf(stderr, "Exiting at cycle 0x%08x\n",
+				psxRegs.cycle);
+			exit(1);
+		}
 
-	if (flags & LIGHTREC_EXIT_SYSCALL)
-		psxException(0x20, 0);
+		if (flags & LIGHTREC_EXIT_SYSCALL)
+			psxException(0x20, 0);
+	}
 
 	psxBranchTest();
 
@@ -532,8 +549,9 @@ static void lightrec_plugin_execute_block(void)
 	}
 
 	if ((psxRegs.cycle & ~0xfffffff) != old_cycle_counter) {
-		printf("RAM usage: IR %u KiB, CODE %u KiB, "
+		printf("RAM usage: Lightrec %u KiB, IR %u KiB, CODE %u KiB, "
 		       "MIPS %u KiB, TOTAL %u KiB, avg. IPI %f\n",
+		       lightrec_get_mem_usage(MEM_FOR_LIGHTREC) / 1024,
 		       lightrec_get_mem_usage(MEM_FOR_IR) / 1024,
 		       lightrec_get_mem_usage(MEM_FOR_CODE) / 1024,
 		       lightrec_get_mem_usage(MEM_FOR_MIPS_CODE) / 1024,