alu.cc

AVR 单片机程序设计用到的模拟器

/* $Id: ALU.cc,v 1.1.1.1 2000/09/24 11:39:10 pure Exp $ */

#include "ALU.h"

ALU::ALU()
{
	SREG = 0;
}

void ALU::clear(byte f)
{
	SREG &= (~f);
}
	
void ALU::set(byte f)
{
	SREG |= (f);
}
	
byte ALU::isset(byte f)
{
	return (SREG & f) ? 1 : 0;
}
	
byte ALU::bit3(byte a)
{
	return (a & 0x08) ? 1 : 0;
}
	
byte ALU::bit7(byte a)
{
	return (a & 0x80) ? 1 : 0;
}

byte ALU::add_with_carry(byte d, byte r, byte c)
{
	byte q = d + r + c;
	SREG &= I|T;
	if ((bit3(d) && bit3(r)) || (bit3(d) && !bit3(q)) || (bit3(r) && !bit3(q))) set(H);  
	if ((bit7(d) && bit7(r)) || (bit7(d) && !bit7(q)) || (bit7(r) && !bit7(q))) set(C);
	if (!q) set(Z);
	if (bit7(q)) set(N);
	if ((bit7(d) && bit7(r) && !bit7(q)) || (!bit7(d) && !bit7(r) && bit7(q))) set(V);
	if (isset(N) ^ isset(V)) set(S);
	return q;
}

byte ALU::sub_with_carry(byte d, byte r, byte c)
{
	byte q = d - r - c;
	SREG &= I|T;
	if ((!bit3(d) && bit3(r)) || (bit3(q) && bit3(r)) || bit3(q) && !bit3(d)) set(H);
	if ((!bit7(d) && bit7(r)) || (bit7(q) && bit7(r)) || bit7(q) && !bit7(d)) set(C);
	if (!q) set(Z);
	if (bit7(q)) set(N);
	if ((bit7(d) && !bit7(r) && !bit7(q)) || (!bit7(d) && bit7(r) && bit7(q))) set(V);
       	if (isset(N) ^ isset(V)) set(S);
	return q;
}

word ALU::addw(word d, byte r)
{
	word q = d + r;
	SREG &= I|T|H;
	if (!(q & 0x8000) && (d & 0x8000)) set(C);
	if (!q) set(Z);
	if (q & 0x8000) set(N);
	if ((q & 0x8000) && !(d & 0x8000)) set(V);
	if (isset(N) ^ isset(V)) set(S);
	return q;
}
	
byte ALU::add(byte d, byte r)
{
	return add_with_carry(d, r, 0);
}
   
byte ALU::adc(byte d, byte r)
{
	return add_with_carry(d, r, SREG & C);
}
	
byte ALU::sub(byte d, byte r)
{
	return sub_with_carry(d, r, 0);
}
   
byte ALU::sbc(byte d, byte r)
{
	byte z = SREG & Z;
	byte q = sub_with_carry(d, r, SREG & C);
	if (isset(Z) && !z) clear(Z);
	return q;
}

word ALU::subw(word d, byte r)
{
	word q = d - r;
	SREG &= I|T|H;
	if ((q & 0x8000) && !(d & 0x8000)) set(C);
	if (!q) set(Z);
	if (q & 0x8000) set(N);
	if (!(q & 0x8000) && (d & 0x8000)) set(V);
	if (isset(N) ^ isset(V)) set(S);
	return q;
}
	
byte ALU::com(byte d)
{
	byte q = 0xff - d;
	SREG &= I|T|H;
	set(C);
	if (!q) set(Z);
	if (bit7(q)) set(N);
	if (isset(N) ^ 0/*V*/) set(S);
	return q;
}

byte ALU::neg(byte d)
{
        byte q = 0x00 - d;
	SREG &= I|T;
	if (bit3(d) || bit3(q)) set(H);
	if (q) set(C);
	if (!q) set(Z);
	if (bit7(q)) set(N);
	if (q == 0x80) set(V);
	if (isset(N) ^ isset(V)) set(S);
	return q;
}
	
byte ALU::inc(byte d)
{
	byte q = d + 1;
	SREG &= I|T|H|C;
	if (!q) set(Z);
	if (bit7(q)) set(N);
	if (d == 0x7f) set(V);
	if (isset(N) ^ isset(V)) set(S);		
	return q;
}
	
byte ALU::dec(byte d)
{
	byte q = d - 1;
	SREG &= I|T|H|C;
	if (!q) set(Z);
	if (bit7(q)) set(N);
	if (d == 0x80) set(V);
	if (isset(N) ^ isset(V)) set(S);
	return q;
}
	
byte ALU::and(byte d, byte r)
{
        byte q = d & r;
	SREG &= I|T|H|C;
	if (!q) set(Z);
	if (bit7(q)) set(N);
	if (isset(N) ^ 0/*V*/) set(S);
	return q;
}

byte ALU::eor(byte d, byte r)
{
	byte q = d ^ r;
	SREG &= I|T|H|C;
	if (!q) set(Z);
	if (bit7(q)) set(N);
	if (isset(N) ^ 0/*V*/) set(S);
	return q;
}
	
byte ALU::ora(byte d, byte r)
{
       	byte q = d | r;
	SREG &= I|T|H|C;
	if (!q) set(Z);
	if (bit7(q)) set(N);
	if (isset(N) ^ 0/*V*/) set(S);
        return q;
}

void ALU::bclr(byte b)
{
	clear(1 << b);
}
	
void ALU::bset(byte b)
{
	set(1 << b);
}
	
byte ALU::bld(byte d, byte b)
{
	d &= ~(1 << b);
	if (isset(T)) b |= (1 << b);
        return d;
}
	
void ALU::bst(byte d, byte b) 
{
	clear(T);
	if (d & (1 << b)) set(T);
}
	
byte ALU::asr(byte d)
{
	byte q = ((d & 0x7f) >> 1) | (d & 0x80);
	SREG &= I|T|H;
        if (d & 1) set(C);
	if (!q) set(Z);
	if (bit7(q)) set(N);
	if (isset(N) ^ isset(C)) set(V);
	if (isset(N) ^ isset(V)) set(S);
	return q;
}
	
byte ALU::lsr(byte d)
{
	byte q = (d >> 1);
	SREG &= I|T|H;
	if (d & 1) set(C);
	if (!q) set(Z);
	if (0/*N*/ ^ isset(C)) set(V);
	if (0/*N*/ ^ isset(V)) set(S);
        return q;
}
	
byte ALU::ror(byte d)
{
	byte q = (d >> 1);
	if (SREG & C) q |= 0x80;
	SREG &= I|T|H;
	if (d & 1) set(C);
	if (!q) set(Z);
	if (bit7(q)) set(N);
	if (isset(N) ^ isset(C)) set(V);
	if (isset(N) ^ isset(V)) set(S);
	return q;
}
	
byte ALU::swap(byte d)
{
	return (d >> 4) | (d << 4);
}