[pcsx_rearmed.git] / deps / lightrec / regcache.c

// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 * Copyright (C) 2014-2021 Paul Cercueil <paul@crapouillou.net>
 */

#include "debug.h"
#include "memmanager.h"
#include "lightning-wrapper.h"
#include "regcache.h"

#include <stdbool.h>
#include <stddef.h>

#define REG_PC (offsetof(struct lightrec_state, curr_pc) / sizeof(u32))

enum reg_priority {
	REG_IS_TEMP,
	REG_IS_TEMP_VALUE,
	REG_IS_ZERO,
	REG_IS_LOADED,
	REG_IS_DIRTY,

	REG_NB_PRIORITIES,
};

struct native_register {
	bool used, output, extend, extended,
	     zero_extend, zero_extended, locked;
	s16 emulated_register;
	intptr_t value;
	enum reg_priority prio;
};

struct regcache {
	struct lightrec_state *state;
	struct native_register lightrec_regs[NUM_REGS + NUM_TEMPS];
};

static const char * mips_regs[] = {
	"zero",
	"at",
	"v0", "v1",
	"a0", "a1", "a2", "a3",
	"t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7",
	"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
	"t8", "t9",
	"k0", "k1",
	"gp", "sp", "fp", "ra",
	"lo", "hi",
};

/* Forward declaration(s) */
static void clean_reg(jit_state_t *_jit,
		      struct native_register *nreg, u8 jit_reg, bool clean);

const char * lightrec_reg_name(u8 reg)
{
	return mips_regs[reg];
}

static inline bool lightrec_reg_is_zero(u8 jit_reg)
{
#if defined(__mips__) || defined(__alpha__) || defined(__riscv)
	if (jit_reg == _ZERO)
		return true;
#endif
	return false;
}

static inline s8 lightrec_get_hardwired_reg(u16 reg)
{
#if defined(__mips__) || defined(__alpha__) || defined(__riscv)
	if (reg == 0)
		return _ZERO;
#endif
	return -1;
}

static inline u8 lightrec_reg_number(const struct regcache *cache,
		const struct native_register *nreg)
{
	return (u8) (((uintptr_t) nreg - (uintptr_t) cache->lightrec_regs)
			/ sizeof(*nreg));
}

static inline u8 lightrec_reg_to_lightning(const struct regcache *cache,
		const struct native_register *nreg)
{
	u8 offset = lightrec_reg_number(cache, nreg);

	if (offset < NUM_REGS)
		return JIT_V(FIRST_REG + offset);
	else
		return JIT_R(FIRST_TEMP + offset - NUM_REGS);
}

static inline struct native_register * lightning_reg_to_lightrec(
		struct regcache *cache, u8 reg)
{
	if ((JIT_V0 > JIT_R0 && reg >= JIT_V0) ||
			(JIT_V0 < JIT_R0 && reg < JIT_R0)) {
		if (JIT_V1 > JIT_V0)
			return &cache->lightrec_regs[reg - JIT_V(FIRST_REG)];
		else
			return &cache->lightrec_regs[JIT_V(FIRST_REG) - reg];
	} else {
		if (JIT_R1 > JIT_R0)
			return &cache->lightrec_regs[NUM_REGS + reg - JIT_R(FIRST_TEMP)];
		else
			return &cache->lightrec_regs[NUM_REGS + JIT_R(FIRST_TEMP) - reg];
	}
}

u8 lightrec_get_reg_in_flags(struct regcache *cache, u8 jit_reg)
{
	struct native_register *reg;
	u8 flags = 0;

	if (lightrec_reg_is_zero(jit_reg))
		return REG_EXT | REG_ZEXT;

	reg = lightning_reg_to_lightrec(cache, jit_reg);
	if (reg->extended)
		flags |= REG_EXT;
	if (reg->zero_extended)
		flags |= REG_ZEXT;

	return flags;
}

void lightrec_set_reg_out_flags(struct regcache *cache, u8 jit_reg, u8 flags)
{
	struct native_register *reg;

	if (!lightrec_reg_is_zero(jit_reg)) {
		reg = lightning_reg_to_lightrec(cache, jit_reg);
		reg->extend = flags & REG_EXT;
		reg->zero_extend = flags & REG_ZEXT;
	}
}

static struct native_register * alloc_temp(struct regcache *cache)
{
	struct native_register *elm, *nreg = NULL;
	enum reg_priority best = REG_NB_PRIORITIES;
	unsigned int i;

	/* We search the register list in reverse order. As temporaries are
	 * meant to be used only in the emitter functions, they can be mapped to
	 * caller-saved registers, as they won't have to be saved back to
	 * memory. */
	for (i = ARRAY_SIZE(cache->lightrec_regs); i; i--) {
		elm = &cache->lightrec_regs[i - 1];

		if (!elm->used && !elm->locked && elm->prio < best) {
			nreg = elm;
			best = elm->prio;

			if (best == REG_IS_TEMP)
				break;
		}
	}

	return nreg;
}

static struct native_register * find_mapped_reg(struct regcache *cache,
						u16 reg, bool out)
{
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(cache->lightrec_regs); i++) {
		struct native_register *nreg = &cache->lightrec_regs[i];
		if ((nreg->prio >= REG_IS_ZERO) &&
		    nreg->emulated_register == reg &&
		    (!out || !nreg->locked))
			return nreg;
	}

	return NULL;
}

static struct native_register * alloc_in_out(struct regcache *cache,
					     u16 reg, bool out)
{
	struct native_register *elm, *nreg = NULL;
	enum reg_priority best = REG_NB_PRIORITIES;
	unsigned int i;

	/* Try to find if the register is already mapped somewhere */
	nreg = find_mapped_reg(cache, reg, out);
	if (nreg)
		return nreg;

	nreg = NULL;

	for (i = 0; i < ARRAY_SIZE(cache->lightrec_regs); i++) {
		elm = &cache->lightrec_regs[i];

		if (!elm->used && !elm->locked && elm->prio < best) {
			nreg = elm;
			best = elm->prio;

			if (best == REG_IS_TEMP)
				break;
		}
	}

	return nreg;
}

static void lightrec_discard_nreg(struct native_register *nreg)
{
	nreg->extended = false;
	nreg->zero_extended = false;
	nreg->output = false;
	nreg->used = false;
	nreg->locked = false;
	nreg->emulated_register = -1;
	nreg->prio = 0;
}

static void lightrec_unload_nreg(struct regcache *cache, jit_state_t *_jit,
		struct native_register *nreg, u8 jit_reg)
{
	clean_reg(_jit, nreg, jit_reg, false);
	lightrec_discard_nreg(nreg);
}

void lightrec_unload_reg(struct regcache *cache, jit_state_t *_jit, u8 jit_reg)
{
	if (lightrec_reg_is_zero(jit_reg))
		return;

	lightrec_unload_nreg(cache, _jit,
			lightning_reg_to_lightrec(cache, jit_reg), jit_reg);
}

u8 lightrec_alloc_reg(struct regcache *cache, jit_state_t *_jit, u8 jit_reg)
{
	struct native_register *reg;

	if (lightrec_reg_is_zero(jit_reg))
		return jit_reg;

	reg = lightning_reg_to_lightrec(cache, jit_reg);
	lightrec_unload_nreg(cache, _jit, reg, jit_reg);

	reg->used = true;
	reg->prio = REG_IS_LOADED;
	return jit_reg;
}

u8 lightrec_alloc_reg_temp(struct regcache *cache, jit_state_t *_jit)
{
	u8 jit_reg;
	struct native_register *nreg = alloc_temp(cache);
	if (!nreg) {
		/* No free register, no dirty register to free. */
		pr_err("No more registers! Abandon ship!\n");
		return 0;
	}

	jit_reg = lightrec_reg_to_lightning(cache, nreg);
	lightrec_unload_nreg(cache, _jit, nreg, jit_reg);

	nreg->prio = REG_IS_TEMP;
	nreg->used = true;
	return jit_reg;
}

s8 lightrec_get_reg_with_value(struct regcache *cache, intptr_t value)
{
	struct native_register *nreg;
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(cache->lightrec_regs); i++) {
		nreg = &cache->lightrec_regs[i];

		if (nreg->prio == REG_IS_TEMP_VALUE && nreg->value == value) {
			nreg->used = true;
			return lightrec_reg_to_lightning(cache, nreg);
		}
	}

	return -1;
}

void lightrec_temp_set_value(struct regcache *cache, u8 jit_reg, intptr_t value)
{
	struct native_register *nreg;

	nreg = lightning_reg_to_lightrec(cache, jit_reg);

	nreg->prio = REG_IS_TEMP_VALUE;
	nreg->value = value;
}

u8 lightrec_alloc_reg_temp_with_value(struct regcache *cache,
				      jit_state_t *_jit, intptr_t value)
{
	s8 reg;

	reg = lightrec_get_reg_with_value(cache, value);
	if (reg < 0) {
		reg = lightrec_alloc_reg_temp(cache, _jit);
		jit_movi((u8)reg, value);
		lightrec_temp_set_value(cache, (u8)reg, value);
	}

	return (u8)reg;
}

u8 lightrec_alloc_reg_out(struct regcache *cache, jit_state_t *_jit,
			  u16 reg, u8 flags)
{
	struct native_register *nreg;
	u8 jit_reg;
	s8 hw_reg;

	hw_reg = lightrec_get_hardwired_reg(reg);
	if (hw_reg >= 0)
		return (u8) hw_reg;

	nreg = alloc_in_out(cache, reg, true);
	if (!nreg) {
		/* No free register, no dirty register to free. */
		pr_err("No more registers! Abandon ship!\n");
		return 0;
	}

	jit_reg = lightrec_reg_to_lightning(cache, nreg);

	/* If we get a dirty register that doesn't correspond to the one
	 * we're requesting, store back the old value */
	if (nreg->emulated_register != reg)
		lightrec_unload_nreg(cache, _jit, nreg, jit_reg);

	nreg->used = true;
	nreg->output = true;
	nreg->emulated_register = reg;
	nreg->extend = flags & REG_EXT;
	nreg->zero_extend = flags & REG_ZEXT;
	nreg->prio = reg ? REG_IS_LOADED : REG_IS_ZERO;
	return jit_reg;
}

u8 lightrec_alloc_reg_in(struct regcache *cache, jit_state_t *_jit,
			 u16 reg, u8 flags)
{
	struct native_register *nreg;
	u8 jit_reg;
	bool reg_changed;
	s8 hw_reg;

	hw_reg = lightrec_get_hardwired_reg(reg);
	if (hw_reg >= 0)
		return (u8) hw_reg;

	nreg = alloc_in_out(cache, reg, false);
	if (!nreg) {
		/* No free register, no dirty register to free. */
		pr_err("No more registers! Abandon ship!\n");
		return 0;
	}

	jit_reg = lightrec_reg_to_lightning(cache, nreg);

	/* If we get a dirty register that doesn't correspond to the one
	 * we're requesting, store back the old value */
	reg_changed = nreg->emulated_register != reg;
	if (reg_changed)
		lightrec_unload_nreg(cache, _jit, nreg, jit_reg);

	if (nreg->prio < REG_IS_LOADED && reg != 0) {
		s16 offset = offsetof(struct lightrec_state, regs.gpr)
			+ (reg << 2);

		nreg->zero_extended = flags & REG_ZEXT;
		nreg->extended = !nreg->zero_extended;

		/* Load previous value from register cache */
		if (nreg->zero_extended)
			jit_ldxi_ui(jit_reg, LIGHTREC_REG_STATE, offset);
		else
			jit_ldxi_i(jit_reg, LIGHTREC_REG_STATE, offset);

		nreg->prio = REG_IS_LOADED;
	}

	/* Clear register r0 before use */
	if (reg == 0 && nreg->prio != REG_IS_ZERO) {
		jit_movi(jit_reg, 0);
		nreg->extended = true;
		nreg->zero_extended = true;
		nreg->prio = REG_IS_ZERO;
	}

	nreg->used = true;
	nreg->output = false;
	nreg->emulated_register = reg;

	if ((flags & REG_EXT) && !nreg->extended &&
	    (!nreg->zero_extended || !(flags & REG_ZEXT))) {
		nreg->extended = true;
		nreg->zero_extended = false;
		jit_extr_i(jit_reg, jit_reg);
	} else if (!(flags & REG_EXT) && (flags & REG_ZEXT) &&
		   !nreg->zero_extended) {
		nreg->zero_extended = true;
		nreg->extended = false;
		jit_extr_ui(jit_reg, jit_reg);
	}

	return jit_reg;
}

void lightrec_remap_reg(struct regcache *cache, jit_state_t *_jit,
			u8 jit_reg, u16 reg_out, bool discard)
{
	struct native_register *nreg;

	lightrec_discard_reg_if_loaded(cache, reg_out);

	nreg = lightning_reg_to_lightrec(cache, jit_reg);
	clean_reg(_jit, nreg, jit_reg, !discard);

	nreg->output = true;
	nreg->emulated_register = reg_out;
	nreg->extend = nreg->extended;
	nreg->zero_extend = nreg->zero_extended;
}

static bool reg_pc_is_mapped(struct regcache *cache)
{
	struct native_register *nreg = lightning_reg_to_lightrec(cache, JIT_V0);

	return nreg->prio == REG_IS_LOADED && nreg->emulated_register == REG_PC;
}

void lightrec_load_imm(struct regcache *cache,
		       jit_state_t *_jit, u8 jit_reg, u32 pc, u32 imm)
{
	s32 delta = imm - pc;

	if (!reg_pc_is_mapped(cache) || !can_sign_extend(delta, 16))
		jit_movi(jit_reg, imm);
	else if (jit_reg != JIT_V0 || delta)
		jit_addi(jit_reg, JIT_V0, delta);
}

void lightrec_load_next_pc_imm(struct regcache *cache,
			       jit_state_t *_jit, u32 pc, u32 imm)
{
	struct native_register *nreg = lightning_reg_to_lightrec(cache, JIT_V0);
	u8 reg = JIT_V0;

	if (lightrec_store_next_pc())
		reg = lightrec_alloc_reg_temp(cache, _jit);

	if (reg_pc_is_mapped(cache)) {
		/* JIT_V0 contains next PC - so we can overwrite it */
		lightrec_load_imm(cache, _jit, reg, pc, imm);
	} else {
		/* JIT_V0 contains something else - invalidate it */
		if (reg == JIT_V0)
		      lightrec_unload_reg(cache, _jit, JIT_V0);

		jit_movi(reg, imm);
	}

	if (lightrec_store_next_pc()) {
		jit_stxi_i(offsetof(struct lightrec_state, next_pc),
			   LIGHTREC_REG_STATE, reg);
		lightrec_free_reg(cache, reg);
	} else {
		nreg->prio = REG_IS_LOADED;
		nreg->emulated_register = -1;
		nreg->locked = true;
	}
}

void lightrec_load_next_pc(struct regcache *cache, jit_state_t *_jit, u8 reg)
{
	struct native_register *nreg_v0, *nreg;
	u16 offset;
	u8 jit_reg;

	if (lightrec_store_next_pc()) {
		jit_reg = lightrec_alloc_reg_in(cache, _jit, reg, 0);
		offset = offsetof(struct lightrec_state, next_pc);
		jit_stxi_i(offset, LIGHTREC_REG_STATE, jit_reg);
		lightrec_free_reg(cache, jit_reg);

		return;
	}

	/* Invalidate JIT_V0 if it is not mapped to 'reg' */
	nreg_v0 = lightning_reg_to_lightrec(cache, JIT_V0);
	if (nreg_v0->prio >= REG_IS_LOADED && nreg_v0->emulated_register != reg)
		lightrec_unload_nreg(cache, _jit, nreg_v0, JIT_V0);

	nreg = find_mapped_reg(cache, reg, false);
	if (!nreg) {
		/* Not mapped - load the value from the register cache */

		offset = offsetof(struct lightrec_state, regs.gpr) + (reg << 2);
		jit_ldxi_ui(JIT_V0, LIGHTREC_REG_STATE, offset);

		nreg_v0->prio = REG_IS_LOADED;
		nreg_v0->emulated_register = reg;

	} else if (nreg == nreg_v0) {
		/* The target register 'reg' is mapped to JIT_V0 */

		if (!nreg->zero_extended)
			jit_extr_ui(JIT_V0, JIT_V0);

	} else {
		/* The target register 'reg' is mapped elsewhere. In that case,
		 * move the register's value to JIT_V0 and re-map it in the
		 * register cache. We can then safely discard the original
		 * mapped register (even if it was dirty). */

		jit_reg = lightrec_reg_to_lightning(cache, nreg);
		if (nreg->zero_extended)
			jit_movr(JIT_V0, jit_reg);
		else
			jit_extr_ui(JIT_V0, jit_reg);

		*nreg_v0 = *nreg;
		lightrec_discard_nreg(nreg);
	}

	if (lightrec_store_next_pc()) {
		jit_stxi_i(offsetof(struct lightrec_state, next_pc),
			   LIGHTREC_REG_STATE, JIT_V0);
	} else {
		lightrec_clean_reg(cache, _jit, JIT_V0);

		nreg_v0->zero_extended = true;
		nreg_v0->locked = true;
	}
}

static void free_reg(struct native_register *nreg)
{
	/* Set output registers as dirty */
	if (nreg->used && nreg->output && nreg->emulated_register > 0)
		nreg->prio = REG_IS_DIRTY;
	if (nreg->output) {
		nreg->extended = nreg->extend;
		nreg->zero_extended = nreg->zero_extend;
	}
	nreg->used = false;
}

void lightrec_free_reg(struct regcache *cache, u8 jit_reg)
{
	if (!lightrec_reg_is_zero(jit_reg))
		free_reg(lightning_reg_to_lightrec(cache, jit_reg));
}

void lightrec_free_regs(struct regcache *cache)
{
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(cache->lightrec_regs); i++)
		free_reg(&cache->lightrec_regs[i]);
}

static void clean_reg(jit_state_t *_jit,
		struct native_register *nreg, u8 jit_reg, bool clean)
{
	/* If we get a dirty register, store back the old value */
	if (nreg->prio == REG_IS_DIRTY) {
		s16 offset = offsetof(struct lightrec_state, regs.gpr)
			+ (nreg->emulated_register << 2);

		jit_stxi_i(offset, LIGHTREC_REG_STATE, jit_reg);

		if (clean) {
			if (nreg->emulated_register == 0)
				nreg->prio = REG_IS_ZERO;
			else
				nreg->prio = REG_IS_LOADED;
		}
	}
}

static void clean_regs(struct regcache *cache, jit_state_t *_jit, bool clean)
{
	unsigned int i;

	for (i = 0; i < NUM_REGS; i++) {
		clean_reg(_jit, &cache->lightrec_regs[i],
			  JIT_V(FIRST_REG + i), clean);
	}
	for (i = 0; i < NUM_TEMPS; i++) {
		clean_reg(_jit, &cache->lightrec_regs[i + NUM_REGS],
				JIT_R(FIRST_TEMP + i), clean);
	}
}

void lightrec_storeback_regs(struct regcache *cache, jit_state_t *_jit)
{
	clean_regs(cache, _jit, false);
}

void lightrec_clean_regs(struct regcache *cache, jit_state_t *_jit)
{
	clean_regs(cache, _jit, true);
}

bool lightrec_has_dirty_regs(struct regcache *cache)
{
	unsigned int i;

	for (i = 0; i < NUM_REGS + NUM_TEMPS; i++)
		if (cache->lightrec_regs[i].prio == REG_IS_DIRTY)
			return true;

	return false;
}

void lightrec_clean_reg(struct regcache *cache, jit_state_t *_jit, u8 jit_reg)
{
	struct native_register *reg;

	if (!lightrec_reg_is_zero(jit_reg)) {
		reg = lightning_reg_to_lightrec(cache, jit_reg);
		clean_reg(_jit, reg, jit_reg, true);
	}
}

bool lightrec_reg_is_loaded(struct regcache *cache, u16 reg)
{
	return !!find_mapped_reg(cache, reg, false);
}

void lightrec_clean_reg_if_loaded(struct regcache *cache, jit_state_t *_jit,
				  u16 reg, bool unload)
{
	struct native_register *nreg;
	u8 jit_reg;

	nreg = find_mapped_reg(cache, reg, false);
	if (nreg) {
		jit_reg = lightrec_reg_to_lightning(cache, nreg);

		if (unload)
			lightrec_unload_nreg(cache, _jit, nreg, jit_reg);
		else
			clean_reg(_jit, nreg, jit_reg, true);
	}
}

void lightrec_discard_reg_if_loaded(struct regcache *cache, u16 reg)
{
	struct native_register *nreg;

	nreg = find_mapped_reg(cache, reg, false);
	if (nreg)
		lightrec_discard_nreg(nreg);
}

struct native_register * lightrec_regcache_enter_branch(struct regcache *cache)
{
	struct native_register *backup;

	backup = lightrec_malloc(cache->state, MEM_FOR_LIGHTREC,
				 sizeof(cache->lightrec_regs));
	memcpy(backup, &cache->lightrec_regs, sizeof(cache->lightrec_regs));

	return backup;
}

void lightrec_regcache_leave_branch(struct regcache *cache,
			struct native_register *regs)
{
	memcpy(&cache->lightrec_regs, regs, sizeof(cache->lightrec_regs));
	lightrec_free(cache->state, MEM_FOR_LIGHTREC,
		      sizeof(cache->lightrec_regs), regs);
}

void lightrec_regcache_reset(struct regcache *cache)
{
	memset(&cache->lightrec_regs, 0, sizeof(cache->lightrec_regs));
}

void lightrec_preload_pc(struct regcache *cache, jit_state_t *_jit)
{
	struct native_register *nreg;

	/* The block's PC is loaded in JIT_V0 at the start of the block */
	nreg = lightning_reg_to_lightrec(cache, JIT_V0);
	nreg->emulated_register = REG_PC;
	nreg->prio = REG_IS_LOADED;
	nreg->zero_extended = true;

	jit_live(JIT_V0);
}

struct regcache * lightrec_regcache_init(struct lightrec_state *state)
{
	struct regcache *cache;

	cache = lightrec_calloc(state, MEM_FOR_LIGHTREC, sizeof(*cache));
	if (!cache)
		return NULL;

	cache->state = state;

	return cache;
}

void lightrec_free_regcache(struct regcache *cache)
{
	return lightrec_free(cache->state, MEM_FOR_LIGHTREC,
			     sizeof(*cache), cache);
}

void lightrec_regcache_mark_live(struct regcache *cache, jit_state_t *_jit)
{
	struct native_register *nreg;
	unsigned int i;

#ifdef _WIN32
	/* FIXME: GNU Lightning on Windows seems to use our mapped registers as
	 * temporaries. Until the actual bug is found and fixed, unconditionally
	 * mark our registers as live here. */
	for (i = 0; i < NUM_REGS; i++) {
		nreg = &cache->lightrec_regs[i];

		if (nreg->used || nreg->prio > REG_IS_TEMP)
			jit_live(JIT_V(FIRST_REG + i));
	}
#endif

	for (i = 0; i < NUM_TEMPS; i++) {
		nreg = &cache->lightrec_regs[NUM_REGS + i];

		if (nreg->used || nreg->prio > REG_IS_TEMP)
			jit_live(JIT_R(FIRST_TEMP + i));
	}

	jit_live(LIGHTREC_REG_STATE);
	jit_live(LIGHTREC_REG_CYCLE);
}
Commit	Line	Data
	1	// SPDX-License-Identifier: LGPL-2.1-or-later
	2	/*
	3	* Copyright (C) 2014-2021 Paul Cercueil <paul@crapouillou.net>
	4	*/
	5
	6	#include "debug.h"
	7	#include "memmanager.h"
	8	#include "lightning-wrapper.h"
	9	#include "regcache.h"
	10
	11	#include <stdbool.h>
	12	#include <stddef.h>
	13
	14	#define REG_PC (offsetof(struct lightrec_state, curr_pc) / sizeof(u32))
	15
	16	enum reg_priority {
	17	REG_IS_TEMP,
	18	REG_IS_TEMP_VALUE,
	19	REG_IS_ZERO,
	20	REG_IS_LOADED,
	21	REG_IS_DIRTY,
	22
	23	REG_NB_PRIORITIES,
	24	};
	25
	26	struct native_register {
	27	bool used, output, extend, extended,
	28	zero_extend, zero_extended, locked;
	29	s16 emulated_register;
	30	intptr_t value;
	31	enum reg_priority prio;
	32	};
	33
	34	struct regcache {
	35	struct lightrec_state *state;
	36	struct native_register lightrec_regs[NUM_REGS + NUM_TEMPS];
	37	};
	38
	39	static const char * mips_regs[] = {
	40	"zero",
	41	"at",
	42	"v0", "v1",
	43	"a0", "a1", "a2", "a3",
	44	"t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7",
	45	"s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
	46	"t8", "t9",
	47	"k0", "k1",
	48	"gp", "sp", "fp", "ra",
	49	"lo", "hi",
	50	};
	51
	52	/* Forward declaration(s) */
	53	static void clean_reg(jit_state_t *_jit,
	54	struct native_register *nreg, u8 jit_reg, bool clean);
	55
	56	const char * lightrec_reg_name(u8 reg)
	57	{
	58	return mips_regs[reg];
	59	}
	60
	61	static inline bool lightrec_reg_is_zero(u8 jit_reg)
	62	{
	63	#if defined(__mips__) \|\| defined(__alpha__) \|\| defined(__riscv)
	64	if (jit_reg == _ZERO)
	65	return true;
	66	#endif
	67	return false;
	68	}
	69
	70	static inline s8 lightrec_get_hardwired_reg(u16 reg)
	71	{
	72	#if defined(__mips__) \|\| defined(__alpha__) \|\| defined(__riscv)
	73	if (reg == 0)
	74	return _ZERO;
	75	#endif
	76	return -1;
	77	}
	78
	79	static inline u8 lightrec_reg_number(const struct regcache *cache,
	80	const struct native_register *nreg)
	81	{
	82	return (u8) (((uintptr_t) nreg - (uintptr_t) cache->lightrec_regs)
	83	/ sizeof(*nreg));
	84	}
	85
	86	static inline u8 lightrec_reg_to_lightning(const struct regcache *cache,
	87	const struct native_register *nreg)
	88	{
	89	u8 offset = lightrec_reg_number(cache, nreg);
	90
	91	if (offset < NUM_REGS)
	92	return JIT_V(FIRST_REG + offset);
	93	else
	94	return JIT_R(FIRST_TEMP + offset - NUM_REGS);
	95	}
	96
	97	static inline struct native_register * lightning_reg_to_lightrec(
	98	struct regcache *cache, u8 reg)
	99	{
	100	if ((JIT_V0 > JIT_R0 && reg >= JIT_V0) \|\|
	101	(JIT_V0 < JIT_R0 && reg < JIT_R0)) {
	102	if (JIT_V1 > JIT_V0)
	103	return &cache->lightrec_regs[reg - JIT_V(FIRST_REG)];
	104	else
	105	return &cache->lightrec_regs[JIT_V(FIRST_REG) - reg];
	106	} else {
	107	if (JIT_R1 > JIT_R0)
	108	return &cache->lightrec_regs[NUM_REGS + reg - JIT_R(FIRST_TEMP)];
	109	else
	110	return &cache->lightrec_regs[NUM_REGS + JIT_R(FIRST_TEMP) - reg];
	111	}
	112	}
	113
	114	u8 lightrec_get_reg_in_flags(struct regcache *cache, u8 jit_reg)
	115	{
	116	struct native_register *reg;
	117	u8 flags = 0;
	118
	119	if (lightrec_reg_is_zero(jit_reg))
	120	return REG_EXT \| REG_ZEXT;
	121
	122	reg = lightning_reg_to_lightrec(cache, jit_reg);
	123	if (reg->extended)
	124	flags \|= REG_EXT;
	125	if (reg->zero_extended)
	126	flags \|= REG_ZEXT;
	127
	128	return flags;
	129	}
	130
	131	void lightrec_set_reg_out_flags(struct regcache *cache, u8 jit_reg, u8 flags)
	132	{
	133	struct native_register *reg;
	134
	135	if (!lightrec_reg_is_zero(jit_reg)) {
	136	reg = lightning_reg_to_lightrec(cache, jit_reg);
	137	reg->extend = flags & REG_EXT;
	138	reg->zero_extend = flags & REG_ZEXT;
	139	}
	140	}
	141
	142	static struct native_register * alloc_temp(struct regcache *cache)
	143	{
	144	struct native_register elm, nreg = NULL;
	145	enum reg_priority best = REG_NB_PRIORITIES;
	146	unsigned int i;
	147
	148	/* We search the register list in reverse order. As temporaries are
	149	* meant to be used only in the emitter functions, they can be mapped to
	150	* caller-saved registers, as they won't have to be saved back to
	151	* memory. */
	152	for (i = ARRAY_SIZE(cache->lightrec_regs); i; i--) {
	153	elm = &cache->lightrec_regs[i - 1];
	154
	155	if (!elm->used && !elm->locked && elm->prio < best) {
	156	nreg = elm;
	157	best = elm->prio;
	158
	159	if (best == REG_IS_TEMP)
	160	break;
	161	}
	162	}
	163
	164	return nreg;
	165	}
	166
	167	static struct native_register * find_mapped_reg(struct regcache *cache,
	168	u16 reg, bool out)
	169	{
	170	unsigned int i;
	171
	172	for (i = 0; i < ARRAY_SIZE(cache->lightrec_regs); i++) {
	173	struct native_register *nreg = &cache->lightrec_regs[i];
	174	if ((nreg->prio >= REG_IS_ZERO) &&
	175	nreg->emulated_register == reg &&
	176	(!out \|\| !nreg->locked))
	177	return nreg;
	178	}
	179
	180	return NULL;
	181	}
	182
	183	static struct native_register * alloc_in_out(struct regcache *cache,
	184	u16 reg, bool out)
	185	{
	186	struct native_register elm, nreg = NULL;
	187	enum reg_priority best = REG_NB_PRIORITIES;
	188	unsigned int i;
	189
	190	/* Try to find if the register is already mapped somewhere */
	191	nreg = find_mapped_reg(cache, reg, out);
	192	if (nreg)
	193	return nreg;
	194
	195	nreg = NULL;
	196
	197	for (i = 0; i < ARRAY_SIZE(cache->lightrec_regs); i++) {
	198	elm = &cache->lightrec_regs[i];
	199
	200	if (!elm->used && !elm->locked && elm->prio < best) {
	201	nreg = elm;
	202	best = elm->prio;
	203
	204	if (best == REG_IS_TEMP)
	205	break;
	206	}
	207	}
	208
	209	return nreg;
	210	}
	211
	212	static void lightrec_discard_nreg(struct native_register *nreg)
	213	{
	214	nreg->extended = false;
	215	nreg->zero_extended = false;
	216	nreg->output = false;
	217	nreg->used = false;
	218	nreg->locked = false;
	219	nreg->emulated_register = -1;
	220	nreg->prio = 0;
	221	}
	222
	223	static void lightrec_unload_nreg(struct regcache cache, jit_state_t _jit,
	224	struct native_register *nreg, u8 jit_reg)
	225	{
	226	clean_reg(_jit, nreg, jit_reg, false);
	227	lightrec_discard_nreg(nreg);
	228	}
	229
	230	void lightrec_unload_reg(struct regcache cache, jit_state_t _jit, u8 jit_reg)
	231	{
	232	if (lightrec_reg_is_zero(jit_reg))
	233	return;
	234
	235	lightrec_unload_nreg(cache, _jit,
	236	lightning_reg_to_lightrec(cache, jit_reg), jit_reg);
	237	}
	238
	239	u8 lightrec_alloc_reg(struct regcache cache, jit_state_t _jit, u8 jit_reg)
	240	{
	241	struct native_register *reg;
	242
	243	if (lightrec_reg_is_zero(jit_reg))
	244	return jit_reg;
	245
	246	reg = lightning_reg_to_lightrec(cache, jit_reg);
	247	lightrec_unload_nreg(cache, _jit, reg, jit_reg);
	248
	249	reg->used = true;
	250	reg->prio = REG_IS_LOADED;
	251	return jit_reg;
	252	}
	253
	254	u8 lightrec_alloc_reg_temp(struct regcache cache, jit_state_t _jit)
	255	{
	256	u8 jit_reg;
	257	struct native_register *nreg = alloc_temp(cache);
	258	if (!nreg) {
	259	/* No free register, no dirty register to free. */
	260	pr_err("No more registers! Abandon ship!\n");
	261	return 0;
	262	}
	263
	264	jit_reg = lightrec_reg_to_lightning(cache, nreg);
	265	lightrec_unload_nreg(cache, _jit, nreg, jit_reg);
	266
	267	nreg->prio = REG_IS_TEMP;
	268	nreg->used = true;
	269	return jit_reg;
	270	}
	271
	272	s8 lightrec_get_reg_with_value(struct regcache *cache, intptr_t value)
	273	{
	274	struct native_register *nreg;
	275	unsigned int i;
	276
	277	for (i = 0; i < ARRAY_SIZE(cache->lightrec_regs); i++) {
	278	nreg = &cache->lightrec_regs[i];
	279
	280	if (nreg->prio == REG_IS_TEMP_VALUE && nreg->value == value) {
	281	nreg->used = true;
	282	return lightrec_reg_to_lightning(cache, nreg);
	283	}
	284	}
	285
	286	return -1;
	287	}
	288
	289	void lightrec_temp_set_value(struct regcache *cache, u8 jit_reg, intptr_t value)
	290	{
	291	struct native_register *nreg;
	292
	293	nreg = lightning_reg_to_lightrec(cache, jit_reg);
	294
	295	nreg->prio = REG_IS_TEMP_VALUE;
	296	nreg->value = value;
	297	}
	298
	299	u8 lightrec_alloc_reg_temp_with_value(struct regcache *cache,
	300	jit_state_t *_jit, intptr_t value)
	301	{
	302	s8 reg;
	303
	304	reg = lightrec_get_reg_with_value(cache, value);
	305	if (reg < 0) {
	306	reg = lightrec_alloc_reg_temp(cache, _jit);
	307	jit_movi((u8)reg, value);
	308	lightrec_temp_set_value(cache, (u8)reg, value);
	309	}
	310
	311	return (u8)reg;
	312	}
	313
	314	u8 lightrec_alloc_reg_out(struct regcache cache, jit_state_t _jit,
	315	u16 reg, u8 flags)
	316	{
	317	struct native_register *nreg;
	318	u8 jit_reg;
	319	s8 hw_reg;
	320
	321	hw_reg = lightrec_get_hardwired_reg(reg);
	322	if (hw_reg >= 0)
	323	return (u8) hw_reg;
	324
	325	nreg = alloc_in_out(cache, reg, true);
	326	if (!nreg) {
	327	/* No free register, no dirty register to free. */
	328	pr_err("No more registers! Abandon ship!\n");
	329	return 0;
	330	}
	331
	332	jit_reg = lightrec_reg_to_lightning(cache, nreg);
	333
	334	/* If we get a dirty register that doesn't correspond to the one
	335	* we're requesting, store back the old value */
	336	if (nreg->emulated_register != reg)
	337	lightrec_unload_nreg(cache, _jit, nreg, jit_reg);
	338
	339	nreg->used = true;
	340	nreg->output = true;
	341	nreg->emulated_register = reg;
	342	nreg->extend = flags & REG_EXT;
	343	nreg->zero_extend = flags & REG_ZEXT;
	344	nreg->prio = reg ? REG_IS_LOADED : REG_IS_ZERO;
	345	return jit_reg;
	346	}
	347
	348	u8 lightrec_alloc_reg_in(struct regcache cache, jit_state_t _jit,
	349	u16 reg, u8 flags)
	350	{
	351	struct native_register *nreg;
	352	u8 jit_reg;
	353	bool reg_changed;
	354	s8 hw_reg;
	355
	356	hw_reg = lightrec_get_hardwired_reg(reg);
	357	if (hw_reg >= 0)
	358	return (u8) hw_reg;
	359
	360	nreg = alloc_in_out(cache, reg, false);
	361	if (!nreg) {
	362	/* No free register, no dirty register to free. */
	363	pr_err("No more registers! Abandon ship!\n");
	364	return 0;
	365	}
	366
	367	jit_reg = lightrec_reg_to_lightning(cache, nreg);
	368
	369	/* If we get a dirty register that doesn't correspond to the one
	370	* we're requesting, store back the old value */
	371	reg_changed = nreg->emulated_register != reg;
	372	if (reg_changed)
	373	lightrec_unload_nreg(cache, _jit, nreg, jit_reg);
	374
	375	if (nreg->prio < REG_IS_LOADED && reg != 0) {
	376	s16 offset = offsetof(struct lightrec_state, regs.gpr)
	377	+ (reg << 2);
	378
	379	nreg->zero_extended = flags & REG_ZEXT;
	380	nreg->extended = !nreg->zero_extended;
	381
	382	/* Load previous value from register cache */
	383	if (nreg->zero_extended)
	384	jit_ldxi_ui(jit_reg, LIGHTREC_REG_STATE, offset);
	385	else
	386	jit_ldxi_i(jit_reg, LIGHTREC_REG_STATE, offset);
	387
	388	nreg->prio = REG_IS_LOADED;
	389	}
	390
	391	/* Clear register r0 before use */
	392	if (reg == 0 && nreg->prio != REG_IS_ZERO) {
	393	jit_movi(jit_reg, 0);
	394	nreg->extended = true;
	395	nreg->zero_extended = true;
	396	nreg->prio = REG_IS_ZERO;
	397	}
	398
	399	nreg->used = true;
	400	nreg->output = false;
	401	nreg->emulated_register = reg;
	402
	403	if ((flags & REG_EXT) && !nreg->extended &&
	404	(!nreg->zero_extended \|\| !(flags & REG_ZEXT))) {
	405	nreg->extended = true;
	406	nreg->zero_extended = false;
	407	jit_extr_i(jit_reg, jit_reg);
	408	} else if (!(flags & REG_EXT) && (flags & REG_ZEXT) &&
	409	!nreg->zero_extended) {
	410	nreg->zero_extended = true;
	411	nreg->extended = false;
	412	jit_extr_ui(jit_reg, jit_reg);
	413	}
	414
	415	return jit_reg;
	416	}
	417
	418	void lightrec_remap_reg(struct regcache cache, jit_state_t _jit,
	419	u8 jit_reg, u16 reg_out, bool discard)
	420	{
	421	struct native_register *nreg;
	422
	423	lightrec_discard_reg_if_loaded(cache, reg_out);
	424
	425	nreg = lightning_reg_to_lightrec(cache, jit_reg);
	426	clean_reg(_jit, nreg, jit_reg, !discard);
	427
	428	nreg->output = true;
	429	nreg->emulated_register = reg_out;
	430	nreg->extend = nreg->extended;
	431	nreg->zero_extend = nreg->zero_extended;
	432	}
	433
	434	static bool reg_pc_is_mapped(struct regcache *cache)
	435	{
	436	struct native_register *nreg = lightning_reg_to_lightrec(cache, JIT_V0);
	437
	438	return nreg->prio == REG_IS_LOADED && nreg->emulated_register == REG_PC;
	439	}
	440
	441	void lightrec_load_imm(struct regcache *cache,
	442	jit_state_t *_jit, u8 jit_reg, u32 pc, u32 imm)
	443	{
	444	s32 delta = imm - pc;
	445
	446	if (!reg_pc_is_mapped(cache) \|\| !can_sign_extend(delta, 16))
	447	jit_movi(jit_reg, imm);
	448	else if (jit_reg != JIT_V0 \|\| delta)
	449	jit_addi(jit_reg, JIT_V0, delta);
	450	}
	451
	452	void lightrec_load_next_pc_imm(struct regcache *cache,
	453	jit_state_t *_jit, u32 pc, u32 imm)
	454	{
	455	struct native_register *nreg = lightning_reg_to_lightrec(cache, JIT_V0);
	456	u8 reg = JIT_V0;
	457
	458	if (lightrec_store_next_pc())
	459	reg = lightrec_alloc_reg_temp(cache, _jit);
	460
	461	if (reg_pc_is_mapped(cache)) {
	462	/* JIT_V0 contains next PC - so we can overwrite it */
	463	lightrec_load_imm(cache, _jit, reg, pc, imm);
	464	} else {
	465	/* JIT_V0 contains something else - invalidate it */
	466	if (reg == JIT_V0)
	467	lightrec_unload_reg(cache, _jit, JIT_V0);
	468
	469	jit_movi(reg, imm);
	470	}
	471
	472	if (lightrec_store_next_pc()) {
	473	jit_stxi_i(offsetof(struct lightrec_state, next_pc),
	474	LIGHTREC_REG_STATE, reg);
	475	lightrec_free_reg(cache, reg);
	476	} else {
	477	nreg->prio = REG_IS_LOADED;
	478	nreg->emulated_register = -1;
	479	nreg->locked = true;
	480	}
	481	}
	482
	483	void lightrec_load_next_pc(struct regcache cache, jit_state_t _jit, u8 reg)
	484	{
	485	struct native_register nreg_v0, nreg;
	486	u16 offset;
	487	u8 jit_reg;
	488
	489	if (lightrec_store_next_pc()) {
	490	jit_reg = lightrec_alloc_reg_in(cache, _jit, reg, 0);
	491	offset = offsetof(struct lightrec_state, next_pc);
	492	jit_stxi_i(offset, LIGHTREC_REG_STATE, jit_reg);
	493	lightrec_free_reg(cache, jit_reg);
	494
	495	return;
	496	}
	497
	498	/* Invalidate JIT_V0 if it is not mapped to 'reg' */
	499	nreg_v0 = lightning_reg_to_lightrec(cache, JIT_V0);
	500	if (nreg_v0->prio >= REG_IS_LOADED && nreg_v0->emulated_register != reg)
	501	lightrec_unload_nreg(cache, _jit, nreg_v0, JIT_V0);
	502
	503	nreg = find_mapped_reg(cache, reg, false);
	504	if (!nreg) {
	505	/* Not mapped - load the value from the register cache */
	506
	507	offset = offsetof(struct lightrec_state, regs.gpr) + (reg << 2);
	508	jit_ldxi_ui(JIT_V0, LIGHTREC_REG_STATE, offset);
	509
	510	nreg_v0->prio = REG_IS_LOADED;
	511	nreg_v0->emulated_register = reg;
	512
	513	} else if (nreg == nreg_v0) {
	514	/* The target register 'reg' is mapped to JIT_V0 */
	515
	516	if (!nreg->zero_extended)
	517	jit_extr_ui(JIT_V0, JIT_V0);
	518
	519	} else {
	520	/* The target register 'reg' is mapped elsewhere. In that case,
	521	* move the register's value to JIT_V0 and re-map it in the
	522	* register cache. We can then safely discard the original
	523	* mapped register (even if it was dirty). */
	524
	525	jit_reg = lightrec_reg_to_lightning(cache, nreg);
	526	if (nreg->zero_extended)
	527	jit_movr(JIT_V0, jit_reg);
	528	else
	529	jit_extr_ui(JIT_V0, jit_reg);
	530
	531	nreg_v0 = nreg;
	532	lightrec_discard_nreg(nreg);
	533	}
	534
	535	if (lightrec_store_next_pc()) {
	536	jit_stxi_i(offsetof(struct lightrec_state, next_pc),
	537	LIGHTREC_REG_STATE, JIT_V0);
	538	} else {
	539	lightrec_clean_reg(cache, _jit, JIT_V0);
	540
	541	nreg_v0->zero_extended = true;
	542	nreg_v0->locked = true;
	543	}
	544	}
	545
	546	static void free_reg(struct native_register *nreg)
	547	{
	548	/* Set output registers as dirty */
	549	if (nreg->used && nreg->output && nreg->emulated_register > 0)
	550	nreg->prio = REG_IS_DIRTY;
	551	if (nreg->output) {
	552	nreg->extended = nreg->extend;
	553	nreg->zero_extended = nreg->zero_extend;
	554	}
	555	nreg->used = false;
	556	}
	557
	558	void lightrec_free_reg(struct regcache *cache, u8 jit_reg)
	559	{
	560	if (!lightrec_reg_is_zero(jit_reg))
	561	free_reg(lightning_reg_to_lightrec(cache, jit_reg));
	562	}
	563
	564	void lightrec_free_regs(struct regcache *cache)
	565	{
	566	unsigned int i;
	567
	568	for (i = 0; i < ARRAY_SIZE(cache->lightrec_regs); i++)
	569	free_reg(&cache->lightrec_regs[i]);
	570	}
	571
	572	static void clean_reg(jit_state_t *_jit,
	573	struct native_register *nreg, u8 jit_reg, bool clean)
	574	{
	575	/* If we get a dirty register, store back the old value */
	576	if (nreg->prio == REG_IS_DIRTY) {
	577	s16 offset = offsetof(struct lightrec_state, regs.gpr)
	578	+ (nreg->emulated_register << 2);
	579
	580	jit_stxi_i(offset, LIGHTREC_REG_STATE, jit_reg);
	581
	582	if (clean) {
	583	if (nreg->emulated_register == 0)
	584	nreg->prio = REG_IS_ZERO;
	585	else
	586	nreg->prio = REG_IS_LOADED;
	587	}
	588	}
	589	}
	590
	591	static void clean_regs(struct regcache cache, jit_state_t _jit, bool clean)
	592	{
	593	unsigned int i;
	594
	595	for (i = 0; i < NUM_REGS; i++) {
	596	clean_reg(_jit, &cache->lightrec_regs[i],
	597	JIT_V(FIRST_REG + i), clean);
	598	}
	599	for (i = 0; i < NUM_TEMPS; i++) {
	600	clean_reg(_jit, &cache->lightrec_regs[i + NUM_REGS],
	601	JIT_R(FIRST_TEMP + i), clean);
	602	}
	603	}
	604
	605	void lightrec_storeback_regs(struct regcache cache, jit_state_t _jit)
	606	{
	607	clean_regs(cache, _jit, false);
	608	}
	609
	610	void lightrec_clean_regs(struct regcache cache, jit_state_t _jit)
	611	{
	612	clean_regs(cache, _jit, true);
	613	}
	614
	615	bool lightrec_has_dirty_regs(struct regcache *cache)
	616	{
	617	unsigned int i;
	618
	619	for (i = 0; i < NUM_REGS + NUM_TEMPS; i++)
	620	if (cache->lightrec_regs[i].prio == REG_IS_DIRTY)
	621	return true;
	622
	623	return false;
	624	}
	625
	626	void lightrec_clean_reg(struct regcache cache, jit_state_t _jit, u8 jit_reg)
	627	{
	628	struct native_register *reg;
	629
	630	if (!lightrec_reg_is_zero(jit_reg)) {
	631	reg = lightning_reg_to_lightrec(cache, jit_reg);
	632	clean_reg(_jit, reg, jit_reg, true);
	633	}
	634	}
	635
	636	bool lightrec_reg_is_loaded(struct regcache *cache, u16 reg)
	637	{
	638	return !!find_mapped_reg(cache, reg, false);
	639	}
	640
	641	void lightrec_clean_reg_if_loaded(struct regcache cache, jit_state_t _jit,
	642	u16 reg, bool unload)
	643	{
	644	struct native_register *nreg;
	645	u8 jit_reg;
	646
	647	nreg = find_mapped_reg(cache, reg, false);
	648	if (nreg) {
	649	jit_reg = lightrec_reg_to_lightning(cache, nreg);
	650
	651	if (unload)
	652	lightrec_unload_nreg(cache, _jit, nreg, jit_reg);
	653	else
	654	clean_reg(_jit, nreg, jit_reg, true);
	655	}
	656	}
	657
	658	void lightrec_discard_reg_if_loaded(struct regcache *cache, u16 reg)
	659	{
	660	struct native_register *nreg;
	661
	662	nreg = find_mapped_reg(cache, reg, false);
	663	if (nreg)
	664	lightrec_discard_nreg(nreg);
	665	}
	666
	667	struct native_register * lightrec_regcache_enter_branch(struct regcache *cache)
	668	{
	669	struct native_register *backup;
	670
	671	backup = lightrec_malloc(cache->state, MEM_FOR_LIGHTREC,
	672	sizeof(cache->lightrec_regs));
	673	memcpy(backup, &cache->lightrec_regs, sizeof(cache->lightrec_regs));
	674
	675	return backup;
	676	}
	677
	678	void lightrec_regcache_leave_branch(struct regcache *cache,
	679	struct native_register *regs)
	680	{
	681	memcpy(&cache->lightrec_regs, regs, sizeof(cache->lightrec_regs));
	682	lightrec_free(cache->state, MEM_FOR_LIGHTREC,
	683	sizeof(cache->lightrec_regs), regs);
	684	}
	685
	686	void lightrec_regcache_reset(struct regcache *cache)
	687	{
	688	memset(&cache->lightrec_regs, 0, sizeof(cache->lightrec_regs));
	689	}
	690
	691	void lightrec_preload_pc(struct regcache cache, jit_state_t _jit)
	692	{
	693	struct native_register *nreg;
	694
	695	/* The block's PC is loaded in JIT_V0 at the start of the block */
	696	nreg = lightning_reg_to_lightrec(cache, JIT_V0);
	697	nreg->emulated_register = REG_PC;
	698	nreg->prio = REG_IS_LOADED;
	699	nreg->zero_extended = true;
	700
	701	jit_live(JIT_V0);
	702	}
	703
	704	struct regcache * lightrec_regcache_init(struct lightrec_state *state)
	705	{
	706	struct regcache *cache;
	707
	708	cache = lightrec_calloc(state, MEM_FOR_LIGHTREC, sizeof(*cache));
	709	if (!cache)
	710	return NULL;
	711
	712	cache->state = state;
	713
	714	return cache;
	715	}
	716
	717	void lightrec_free_regcache(struct regcache *cache)
	718	{
	719	return lightrec_free(cache->state, MEM_FOR_LIGHTREC,
	720	sizeof(*cache), cache);
	721	}
	722
	723	void lightrec_regcache_mark_live(struct regcache cache, jit_state_t _jit)
	724	{
	725	struct native_register *nreg;
	726	unsigned int i;
	727
	728	#ifdef _WIN32
	729	/* FIXME: GNU Lightning on Windows seems to use our mapped registers as
	730	* temporaries. Until the actual bug is found and fixed, unconditionally
	731	* mark our registers as live here. */
	732	for (i = 0; i < NUM_REGS; i++) {
	733	nreg = &cache->lightrec_regs[i];
	734
	735	if (nreg->used \|\| nreg->prio > REG_IS_TEMP)
	736	jit_live(JIT_V(FIRST_REG + i));
	737	}
	738	#endif
	739
	740	for (i = 0; i < NUM_TEMPS; i++) {
	741	nreg = &cache->lightrec_regs[NUM_REGS + i];
	742
	743	if (nreg->used \|\| nreg->prio > REG_IS_TEMP)
	744	jit_live(JIT_R(FIRST_TEMP + i));
	745	}
	746
	747	jit_live(LIGHTREC_REG_STATE);
	748	jit_live(LIGHTREC_REG_CYCLE);
	749	}