shithub: 5v

ref: f1f56304b68bf740f6f282ed270fee7e9f9596e1
dir: 5v/arm.c

#include <u.h>
#include <libc.h>
#include <thread.h>
#include <bio.h>
#include <mach.h>
#include "dat.h"
#include "fns.h"

enum {
	fI = 1<<25,
	fP = 1<<24,
	fLi = 1<<24,
	fU = 1<<23,
	fB = 1<<22,
	fW = 1<<21,
	fL = 1<<20,
	fS = 1<<20,
	fSg = 1<<6,
	fH = 1<<5,
};

u32int mallocaddr;
u32int freeaddr;
u32int reallocaddr;
u32int sbrkaddr;
u32int setmalloctagaddr;
u32int setrealloctagaddr;

static u32int
arg(int n)
{
	/* no locking necessary, since we're on the stack */
	if(n == 0)
		return P->R[0];
	else
		return *(u32int*) vaddrnol(P->R[13] + 4 + 4 * n, 4, ARD);
}

static u32int
asize(int n)
{
	/* keep in sync with Bhdr in pool.c */
	u32int a;

	a = *(u32int*) vaddrnol(P->R[13] + 4 + 4 * n, 4, ARD);
	if(a == 0)
		return ~0;
	return *(ulong*) vaddrnol(a-4, 4, 0);
}

void
invalid(u32int instr)
{
	suicide("undefined instruction %8ux @ %8ux", instr, P->R[15] - 4);
}

u32int
evenaddr(u32int addr, u32int mask)
{
	if((addr & mask) == 0)
		return addr;
	suicide("unaligned access %8ux @ %8ux", addr, P->R[15] - 4);
	return addr & ~mask;
}

static u32int
doshift(u32int instr, u8int *carry)
{
	ulong amount, val;

	val = P->R[instr & 15];
	if(instr & (1<<4)) {
		if(instr & (1<<7))
			invalid(instr);
		amount = P->R[(instr >> 8) & 15] & 0xFF;
		if(amount == 0)
			return val;
	} else {
		amount = (instr >> 7) & 31;
		if(amount == 0 && (instr & (3<<5)) != 0)
			amount = 32;
	}
	switch((instr >> 5) & 3) {
	default:
		if(amount == 0)
			return val;
		if(amount < 32) {
			*carry = (val >> (32 - amount)) & 1;
			return val << amount;
		}
		*carry = val & 1;
		return 0;
	case 1:
		if(amount < 32){
			*carry = (val >> (amount - 1)) & 1;
			return val >> amount;
		}
		*carry = val >> 31;
		return 0;
	case 2:
		if(amount < 32){
			*carry = (val >> (amount - 1)) & 1;
			return ((long) val) >> amount;
		}
		if((long)val < 0){
			*carry = 1;
			return -1;
		}
		*carry = 0;
		return 0;
	case 3:
		amount &= 31;
		if(amount){
			*carry = (val >> (amount - 1)) & 1;
			return (val >> amount) | (val << (32 - amount));
		}
		amount = *carry & 1;
		*carry = val & 1;
		return (val>>1) | (amount<<31);
	}
}

static void
single(u32int instr)
{
	long offset;
	u32int addr;
	u32int *Rn, *Rd;
	void *targ;
	Segment *seg;
	
	if(instr & fI) {
		u8int carry = 0;
		if(instr & (1<<4))
			invalid(instr);
		offset = doshift(instr, &carry);
	} else
		offset = instr & ((1<<12) - 1);
	if(!(instr & fU))
		offset = - offset;
	Rn = P->R + ((instr >> 16) & 15);
	Rd = P->R + ((instr >> 12) & 15);
	if((instr & (fW | fP)) == fW)
		invalid(instr);
	if(Rn == P->R + 15) {
		if(instr & fW)
			invalid(instr);
		addr = P->R[15] + 4;
	}else
		addr = *Rn;
	if(instr & fP)
		addr += offset;
	if((instr & fB) == 0)
		addr = evenaddr(addr, 3);
	switch(instr & (fB | fL)) {
	case 0:
		targ = vaddr(addr, 4, AWR, &seg);
		*(u32int*) targ = *Rd;
		break;
	case fB:
		targ = vaddr(addr, 1, AWR, &seg);
		*(u8int*) targ = *Rd;
		break;
	case fL:
		targ = vaddr(addr, 4, ARD, &seg);
		*Rd = *(u32int*) targ;
		break;
	case fB | fL:
		targ = vaddr(addr, 1, ARD, &seg);
		*Rd = *(u8int*) targ;
		break;
	default:
		targ = nil;
		abort();
	}
	if(Rd == P->R + 15 && !(instr & fL)) {
		if(instr & fB)
			*(u8int*) targ += 8;
		else
			*(u32int*) targ += 8;
	}
	segunlock(seg);
	if(!(instr & fP))
		addr += offset;
	if((instr & fW) || !(instr & fP))
		*Rn = addr;
}

/* atomic compare and swap from libc */
extern int cas(u32int *p, u32int old, u32int new);

static void
swap(u32int instr)
{
	u32int *Rm, *Rn, *Rd, *targ, addr, old, new;
	Segment *seg;
	
	Rm = P->R + (instr & 15);
	Rd = P->R + ((instr >> 12) & 15);
	Rn = P->R + ((instr >> 16) & 15);
	if(Rm == P->R + 15 || Rd == P->R + 15 || Rn == P->R + 15)
		invalid(instr);
	addr = *Rn;
	if((instr & fB) == 0)
		addr = evenaddr(addr, 3);
	targ = (u32int *) vaddr(addr & ~3, 4, ARD|AWR, &seg);
	do {
		old = *targ;
		new = *Rm;
		if(instr & fB){
			new &= 0xFF;
			new <<= 8*(addr&3);
			new |= old & ~(0xFF << 8*(addr&3));
		}
	} while(!cas(targ, old, new));
	if(instr & fB) {
		old >>= 8*(addr&3);
		old &= 0xFF;
	}
	*Rd = old;
	segunlock(seg);
}

static u32int
add(u32int a, u32int b, u8int type, u8int *carry, u8int *overflow)
{
	u32int res1;
	u64int res2;

	if(type) {
		res2 = (u64int)a - b + *carry - 1;
		res1 = res2;
		if(((a ^ b) & (1<<31)) && !((b ^ res1) & (1<<31)))
			*overflow = 1;
		else
			*overflow = 0;
		if(res2 & 0x100000000LL)
			*carry = 0;
		else
			*carry = 1;	
	} else {
		res2 = (u64int)a + b + *carry;
		res1 = res2;
		if(!((a ^ b) & (1<<31)) && ((b ^ res1) & (1<<31)))
			*overflow = 1;
		else
			*overflow = 0;
		if(res2 & 0x100000000LL)
			*carry = 1;
		else *carry = 0;
	}
	return res1;
}

static void
alu(u32int instr)
{
	u32int Rn, *Rd, operand, shift, result, op;
	u8int carry, overflow;
	
	Rn = P->R[(instr >> 16) & 15];
	Rd = P->R + ((instr >> 12) & 15);
	if(((instr >> 16) & 15) == 15) {
		Rn += 4;
		if(!(instr & fI) && (instr & (1<<4)))
			Rn += 4;
	}
	if(Rd == P->R + 15 && (instr & fS))
		invalid(instr);

	carry = (P->CPSR & flC) != 0;
	overflow = (P->CPSR & flV) != 0;

	if(instr & fI) {
		operand = instr & 0xFF;
		shift = ((instr >> 8) & 15) << 1;
		if(shift){
			operand = (operand >> shift) | (operand << (32 - shift));
			carry = operand >> 31;
		}
	} else
		operand = doshift(instr, &carry);

	op = (instr >> 21) & 15;
	if(op >= 8 && op <= 11 && !(instr & fS))
		sysfatal("no PSR transfers plz");
	if(op >= 5 && op < 8)
		carry = (P->CPSR & flC) != 0;
	switch(op) {
	case 0: case 8: result = Rn & operand; break;
	case 1: case 9: result = Rn ^ operand; break;
	case 2: case 10: carry = 1; case 6: result = add(Rn, operand, 1, &carry, &overflow); break;
	case 3:          carry = 1; case 7: result = add(operand, Rn, 1, &carry, &overflow); break;
	case 4: case 11: carry = 0; case 5: result = add(operand, Rn, 0, &carry, &overflow); break;
	case 12: result = Rn | operand; break;
	case 13: result = operand; break;
	case 14: result = Rn & ~operand; break;
	case 15: result = ~operand; break;
	default: result = 0; /* never happens */
	}
	if(instr & fS) {
		P->CPSR &= ~FLAGS;
		if(result == 0)
			P->CPSR |= flZ;
		if(result & (1<<31))
			P->CPSR |= flN;
		if(carry)
			P->CPSR |= flC;
		if(overflow)
			P->CPSR |= flV;
	}
	if(op < 8 || op >= 12)
		*Rd = result;
}

static void
branch(u32int instr)
{
	long offset;
	u32int npc;
	
	offset = instr & ((1<<24) - 1);
	if(offset & (1<<23))
		offset |= ~((1 << 24) - 1);
	offset *= 4;
	npc = P->R[15] + offset + 4;
	if(instr & fLi){
		P->R[14] = P->R[15];
		if(check && P->hookpc == 0){
			if(npc == mallocaddr){
				P->hookarg[0] = arg(1);	/* size */
				P->hookfn = hookmalloc;
				P->hookpc = P->R[15];
			}else if(npc == reallocaddr){
				P->hookarg[0] = arg(1);		/* old */
				P->hookarg[1] = asize(1);	/* oldsz */
				P->hookarg[2] = arg(2);		/* newsz */
				P->hookfn = hookrealloc;
				P->hookpc = P->R[15];
			}else if(npc == freeaddr){
				P->hookarg[0] = arg(1);
				P->hookarg[1] = asize(1);
				P->hookfn = hookfree;
				P->hookpc = P->R[15];
			}else if(npc == sbrkaddr){
				P->hookarg[0] = arg(0);
				P->hookarg[1] = asize(1);
				P->hookfn = hookfree;
				P->hookpc = P->R[15];
			}else if(npc == setmalloctagaddr){
				P->hookpc = P->R[15];
			}else if(npc == setrealloctagaddr){
				P->hookpc = P->R[15];
			}
		}
	}
	P->R[15] = npc;
}

static void
halfword(u32int instr)
{
	u32int offset, target, *Rn, *Rd;
	Segment *seg;
	
	if(instr & (1<<22)) {
		offset = (instr & 15) | ((instr >> 4) & 0xF0);
	} else {
		if((instr & 15) == 15)
			invalid(instr);
		offset = P->R[instr & 15];
	}
	if(!(instr & fU))
		offset = - offset;
	if(!(instr & fP) && (instr & fW))
		invalid(instr);
	Rn = P->R + ((instr >> 16) & 15);
	Rd = P->R + ((instr >> 12) & 15);
	if(Rn == P->R + 15 || Rd == P->R + 15)
		sysfatal("R15 in halfword");
	target = *Rn;
	if(instr & fP)
		target += offset;
	if(instr & fH)
		target = evenaddr(target, 1);
	switch(instr & (fSg | fH | fL)) {
	case fSg:
		*(u8int*) vaddr(target, 1, AWR, &seg) = *Rd;
		break;
	case fSg | fL:
		*Rd = (long) *(char*) vaddr(target, 1, ARD, &seg);
		break;
	case fH: case fSg | fH:
		*(u16int*) vaddr(target, 2, AWR, &seg) = *Rd;
		break;
	case fH | fL:
		*Rd = *(u16int*) vaddr(target, 2, ARD, &seg);
		break;
	case fH | fL | fSg:
		*Rd = (long) *(short*) vaddr(target, 2, ARD, &seg);
		break;
	}
	segunlock(seg);
	if(!(instr & fP))
		target += offset;
	if(!(instr & fP) || (instr & fW))
		*Rn = target;
}

static void
block(u32int instr)
{
	int i;
	u32int targ, *Rn;
	Segment *seg;

	if(instr & (1<<22))
		invalid(instr);
	Rn = P->R + ((instr >> 16) & 15);
	if(Rn == P->R + 15 || instr & (1<<15))
		sysfatal("R15 block");
	targ = evenaddr(*Rn, 3);
	if(instr & fU) {
		for(i = 0; i < 16; i++) {
			if(!(instr & (1<<i)))
				continue;
			if(instr & fP)
				targ += 4;
			if(instr & fL)
				P->R[i] = *(u32int*) vaddr(targ, 4, ARD, &seg);
			else
				*(u32int*) vaddr(targ, 4, AWR, &seg) = P->R[i];
			segunlock(seg);
			if(!(instr & fP))
				targ += 4;
		}
	} else {
		for(i = 15; i >= 0; i--) {
			if(!(instr & (1<<i)))
				continue;
			if(instr & fP)
				targ -= 4;
			if(instr & fL)
				P->R[i] = *(u32int*) vaddr(targ, 4, ARD, &seg);
			else
				*(u32int*) vaddr(targ, 4, AWR, &seg) = P->R[i];
			segunlock(seg);
			if(!(instr & fP))
				targ -= 4;
		}
	}
	if(instr & fW)
		*Rn = targ;
}

static void
multiply(u32int instr)
{
	u32int *Rd, *Rn, *Rs, *Rm, res;
	
	Rm = P->R + (instr & 15);
	Rs = P->R + ((instr >> 8) & 15);
	Rn = P->R + ((instr >> 12) & 15);
	Rd = P->R + ((instr >> 16) & 15);
	if(Rd == Rm || Rm == P->R + 15 || Rs == P->R + 15 || Rn == P->R + 15 || Rd == P->R + 15)
		invalid(instr);
	res = *Rm * *Rs;
	if(instr & (1<<21))
		res += *Rn;
	*Rd = res;
	if(instr & (1<<20)) {
		P->CPSR &= ~(flN | flZ);
		if(res & (1<<31))
			P->CPSR |= flN;
		if(res == 0)
			P->CPSR |= flZ;
	}
}

static void
multiplylong(u32int instr)
{
	u32int *RdH, *RdL, *Rs, *Rm;
	u64int res;
	
	Rm = P->R + (instr & 15);
	Rs = P->R + ((instr >> 8) & 15);
	RdL = P->R + ((instr >> 12) & 15);
	RdH = P->R + ((instr >> 16) & 15);
	if(RdL == RdH || RdH == Rm || RdL == Rm || Rm == P->R + 15
	|| Rs == P->R + 15 || RdL == P->R + 15 || RdH == P->R + 15)
		invalid(instr);
	if(instr & (1<<22))
		res = ((vlong)*(int*)Rs) * *(int*)Rm;
	else {
		res = *Rs;
		res *= *Rm;
	}
	if(instr & (1<<21)) {
		res += *RdL;
		res += ((uvlong)*RdH) << 32;
	}
	*RdL = res;
	*RdH = res >> 32;
	if(instr & (1<<20)) {
		P->CPSR &= ~FLAGS;
		if(res == 0)
			P->CPSR |= flN;
		if(res & (1LL<<63))
			P->CPSR |= flV;
	}
}

static void
singleex(u32int instr)
{
	u32int *Rn, *Rd, *Rm, *targ, addr;
	Segment *seg;
	
	Rd = P->R + ((instr >> 12) & 15);
	Rn = P->R + ((instr >> 16) & 15);
	if(Rd == P->R + 15 || Rn == P->R + 15)
		invalid(instr);
	addr = evenaddr(*Rn, 3);
	if(instr & fS) {
		targ = vaddr(addr, 4, ARD, &seg);
		*Rd = *targ;
		P->lladdr = addr;
		P->llval = *Rd;
		segunlock(seg);
	} else {
		Rm = P->R + (instr & 15);
		if(Rm == P->R + 15)
			invalid(instr);
		targ = vaddr(addr, 4, ARD|AWR, &seg);

		/*
		 * this is not quite correct as we will succeed even
		 * if the value was modified and then restored to its
		 * original value but good enougth approximation for
		 * libc's _tas(), _cas() and _xinc()/_xdec().
		 */
		*Rd = addr != P->lladdr || !cas(targ, P->llval, *Rm);
		segunlock(seg);
		clrex();
	}
}

void
clrex(void)
{
	P->lladdr = 0;
	P->llval = 0;
}

static void
barrier(void)
{
	static Lock l;

	lock(&l);
	unlock(&l);
}

void
step(void)
{
	u32int instr;
	Segment *seg;

	instr = *(u32int*) vaddr(P->R[15], 4, 0, &seg);
	segunlock(seg);
	if(fulltrace) {
		print("%d ", P->pid);
		Symbol s;
		char buf[512];
		
		if(findsym(P->R[15], CTEXT, &s) >= 0)
			print("%s ", s.name);
		if(fileline(buf, 512, P->R[15]) >= 0)
			print("%s ", buf);
		print("%.8ux %.8ux %c%c%c%c\n", P->R[15], instr,
			(P->CPSR & flZ) ? 'Z' : ' ',
			(P->CPSR & flC) ? 'C' : ' ',
			(P->CPSR & flN) ? 'N' : ' ',
			(P->CPSR & flV) ? 'V' : ' '
			);
	}
	if(P->R[15] == P->hookpc){
		if(P->hookfn)
			P->hookfn(P->hookarg);
		P->hookpc = 0;
		P->hookfn = nil;
	}
	P->R[15] += 4;
	switch(instr >> 28) {
	case 0x0: if(!(P->CPSR & flZ)) return; break;
	case 0x1: if(P->CPSR & flZ) return; break;
	case 0x2: if(!(P->CPSR & flC)) return; break;
	case 0x3: if(P->CPSR & flC) return; break;
	case 0x4: if(!(P->CPSR & flN)) return; break;
	case 0x5: if(P->CPSR & flN) return; break;
	case 0x6: if(!(P->CPSR & flV)) return; break;
	case 0x7: if(P->CPSR & flV) return; break;
	case 0x8: if(!(P->CPSR & flC) || (P->CPSR & flZ)) return; break;
	case 0x9: if((P->CPSR & flC) && !(P->CPSR & flZ)) return; break;
	case 0xA: if(!(P->CPSR & flN) != !(P->CPSR & flV)) return; break;
	case 0xB: if(!(P->CPSR & flN) == !(P->CPSR & flV)) return; break;
	case 0xC: if((P->CPSR & flZ) || !(P->CPSR & flN) != !(P->CPSR & flV)) return; break;
	case 0xD: if(!(P->CPSR & flZ) && !(P->CPSR & flN) == !(P->CPSR & flV)) return; break;
	case 0xE: break;
	case 0xF:
		switch(instr & 0xFFF000F0){
		case 0xF5700010:	/* CLREX */
			clrex();
			return;
		case 0xF5700040:	/* DSB */
		case 0xF5700050:	/* DMB */
		case 0xF5700060:	/* ISB */
			barrier();
			return;
		}
	default: sysfatal("condition code %x not implemented (instr %ux, ps %ux)", instr >> 28, instr, P->R[15]);
	}
	if((instr & 0x0FB00FF0) == 0x01000090)
		swap(instr);
	else if((instr & 0x0FE000F0) == 0x01800090)
		singleex(instr);
	else if((instr & 0x0FC000F0) == 0x90)
		multiply(instr);
	else if((instr & 0x0F8000F0) == 0x800090)
		multiplylong(instr);
	else if((instr & ((1<<26) | (1<<27))) == (1 << 26))
		single(instr);
	else if((instr & 0x0E000090) == 0x90 && (instr & 0x60))
		halfword(instr);
	else if((instr & ((1<<26) | (1<<27))) == 0)
		alu(instr);
	else if((instr & (7<<25)) == (5 << 25))
		branch(instr);
	else if((instr & (15<<24)) == (15 << 24))
		syscall();
	else if((instr & (7<<25)) == (4 << 25))
		block(instr);
	else if((instr & 0x0E000F00) == 0x0C000100)
		fpatransfer(instr);
	else if((instr & 0x0E000F10) == 0x0E000100)
		fpaoperation(instr);
	else if((instr & 0x0E000F10) == 0x0E000110)
		fparegtransfer(instr);
	else if(vfp && ((instr & 0x0F000A10) == 0x0E000A00))
		vfpoperation(instr);
	else if(vfp && ((instr & 0x0F000F10) == 0x0E000A10))
		vfpregtransfer(instr);
	else if(vfp && ((instr & 0x0F000A00) == 0x0D000A00))
		vfprmtransfer(instr);
	else
		invalid(instr);
}