ack/plat/linuxppc/emu/emu.c

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <strings.h>
#include <math.h>
#include "emu.h"

#define BO4 (1<<0)
#define BO3 (1<<1)
#define BO2 (1<<2)
#define BO1 (1<<3)
#define BO0 (1<<4)

#define XER_SO (1<<31)
#define XER_OV (1<<30)
#define XER_CA (1<<29)

cpu_t cpu;

static inline bool carry(void)
{
	fatal("carry() not supported yet");
}

/* Byte-swaps a 16-bit value. */
static inline uint16_t swb16(uint16_t n)
{
	return
		(((n >> 8) & 0xff) |
		((n & 0xff) << 8));
}

/* Byte-swaps a 32-bit value. */
static inline uint32_t swb32(uint32_t n)
{
	return 
		(((n & 0xff000000) >> 24) |
		((n & 0x00ff0000) >> 8) |
		((n & 0x0000ff00) << 8) |
		((n & 0x000000ff) << 24));
}

/* Returns the state of a carry flag after a three-way add. */
static inline bool carry_3(uint32_t a, uint32_t b, uint32_t c)
{
	if ((a+b) < a)
		return true;
	if ((a+b+c) < c)
		return true;
	return false;
}

static inline uint32_t reg(uint8_t n)
{
	return cpu.gpr[n];
}

static inline uint32_t reg0(uint8_t n)
{
	if (n == 0)
		return 0;
	return cpu.gpr[n];
}

/* Double to bytes */
static inline uint64_t d2b(double n)
{
	return *(uint64_t*)&n;
}

/* Float to bytes */
static inline uint32_t f2b(float n)
{
	return *(uint32_t*)&n;
}

/* Bytes to double */
static inline double b2d(uint64_t n)
{
	return *(double*)&n;
}

/* Bytes to float */
static inline float b2f(uint32_t n)
{
	return *(float*)&n;
}

static inline double fpr(uint8_t n)
{
	return b2d(cpu.fpr[n]);
}

static inline uint32_t ext8(int8_t n)
{
	return (n << 24) >> 24;
}

static inline uint32_t ext16(int16_t n)
{
	return (n << 16) >> 16;
}

static inline uint32_t ext26(int32_t n)
{
	return (n << 6) >> 6;
}

static bool getcr(uint8_t bit)
{
	bit = 31 - bit; /* note PowerPC bit numbering */
	return cpu.cr & (1<<bit);
}

static void setcr(uint8_t bit, bool value)
{
	bit = 31 - bit; /* note PowerPC bit numbering */
	cpu.cr = cpu.cr & ~(1<<bit) | (value<<bit);
}

static void setcr0(bool setcr0, uint32_t value)
{
	if (setcr0)
	{
		setcr(0, (int32_t)value < 0);
		setcr(1, (int32_t)value > 0);
		setcr(2, value == 0);
		setcr(3, cpu.xer & (1<<31));
	}
}

static void setcr1(bool setcr1, uint64_t value)
{
	if (setcr1)
		fatal("setcr1 not implemented yet");
}

static void mcrf(uint8_t destfield, uint8_t srcfield)
{
	fatal("mcrf not supported yet");
}

static void branch(uint8_t bo, uint8_t bi, uint32_t dest, bool a_bit, bool l_bit)
{
	bool bo0 = bo & BO0;
	bool bo1 = bo & BO1;
	bool bo2 = bo & BO2;
	bool bo3 = bo & BO3;
	bool ctr_ok;
	bool cond_ok;

	if (!bo2)
		cpu.ctr--;
	ctr_ok = bo2 || (!!cpu.ctr ^ bo3);
	cond_ok = bo0 || (!!(cpu.cr & (1<<(31-bi))) == bo1);
	if (ctr_ok && cond_ok)
	{
		if (a_bit)
			cpu.nia = dest;
		else
			cpu.nia = dest + cpu.cia;
	}
	if (l_bit)
		cpu.lr = cpu.cia + 4;
}

static void read_multiple(uint32_t address, uint8_t reg)
{
	while (reg != 32)
	{
		cpu.gpr[reg] = read_long(address);
		reg++;
		address += 4;
	}
}

static void write_multiple(uint32_t address, uint8_t reg)
{
	while (reg != 32)
	{
		write_long(address, cpu.gpr[reg]);
		reg++;
		address += 4;
	}
}

static void read_string(uint32_t address, uint8_t reg, uint8_t bytes)
{
	fatal("read_string not supported yet");
}

static void write_string(uint32_t address, uint8_t reg, uint8_t bytes)
{
	fatal("write_string not supported yet");
}

static uint32_t addo(uint32_t a, uint32_t b, uint32_t c, bool set_o, bool set_c)
{
	if (set_o)
		fatal("can't use O bit in add yet");
	
	if (set_c)
	{
		cpu.xer = cpu.xer & ~XER_CA;
		if (carry_3(a, b, c))
			cpu.xer = cpu.xer | XER_CA;
	}

	return a + b + c;
}

static uint32_t mulo(uint32_t a, uint32_t b, bool set_o)
{
	if (set_o)
		fatal("can't use O bit in mul yet");
	
	return a * b;
}

static int32_t divo(int32_t a, int32_t b, bool set_o)
{
	if (set_o)
		fatal("can't use O bit in div yet");
	
	if (b == 0)
		return 0;
	return a / b;
}

static uint32_t divuo(uint32_t a, uint32_t b, bool set_o)
{
	if (set_o)
		fatal("can't use O bit in divu yet");
	
	if (b == 0)
		return 0;
	return a / b;
}

static void compares(int32_t a, int32_t b, uint8_t field)
{
	uint8_t bit = field*4;
	setcr(bit+0, a<b);
	setcr(bit+1, a>b);
	setcr(bit+2, a==b);
	setcr(bit+3, cpu.xer & (1<<31));
}

static void compareu(uint32_t a, uint32_t b, uint8_t field)
{
	uint8_t bit = field*4;
	setcr(bit+0, a<b);
	setcr(bit+1, a>b);
	setcr(bit+2, a==b);
	setcr(bit+3, cpu.xer & (1<<31));
}

static void comparef(double a, double b, uint8_t field)
{
	uint8_t c;
	if (isnan(a) || isnan(b))
		c = 0x1;
	else if (a < b)
		c = 0x8;
	else if (a > b)
		c = 0x4;
	else
		c = 0x2;
	
	uint8_t bit = 28 - field*4; /* note PowerPC bit numbering */
	cpu.cr = cpu.cr & ~(0xf<<bit) | (c<<bit);

	/* TODO: ordered/unordered, FSPCR, etc. */
}

static uint32_t cntlzw(uint32_t source)
{
	return 32 - ffs(source);
}

static uint32_t popcntb(uint32_t source)
{
	fatal("popcntb not supported");
}

static uint32_t rotate(uint32_t i, uint32_t shift)
{
	return (i << shift) | (i >> (32-shift));
}

static uint32_t rlwnm(uint32_t source, uint8_t shift, uint8_t mb, uint8_t me)
{
	uint8_t masksize = 1 + me - mb; /* me and mb are inclusive */
	uint32_t mask = (((uint64_t)1<<masksize)-1) << (31 - me);
	return rotate(source, shift) & mask;
}

static uint32_t rlwmi(uint32_t source, uint8_t shift, uint8_t mb, uint8_t me)
{
	fatal("rlwmi not supported");
}

static void mtcrf(uint8_t fxm, uint32_t value)
{
	fatal("mtcrf not supported");
}

static void dispatch(uint32_t value)
{
	#include "dispatcher.h"
	fatal("unimplemented instruction 0x%0x (major opcode %d)", value, value>>26);
}

void dump_state(FILE* stream)
{
	int i;

	fprintf(stream, "\n");
	fprintf(stream, "pc=0x%08x lr=0x%08x ctr=0x%08x xer=0x%08x cr=0x%08x",
		cpu.cia, cpu.lr, cpu.ctr, cpu.xer, cpu.cr);
	for (i=0; i<32; i++)
	{
		if ((i % 4) == 0)
			fprintf(stream, "\n");
		fprintf(stream, "gpr%02d=0x%08x ", i, cpu.gpr[i]);
	}
	fprintf(stderr, "\n");

	/* This might fail and cause a reentrant trap if cia is invalid, so
	 * do it last. */
	fprintf(stream, "insn=0x%08x\n", read_long(cpu.cia));
}

void single_step(void)
{
	uint32_t value = read_long(cpu.cia);
	cpu.nia = cpu.cia + 4;
	dispatch(value);
	cpu.cia = cpu.nia;
}