OSDev.org

Code: Select all

InstallOp(0xFE,inc_dec_r8);

Code: Select all

void inc_dec_r8();

SPEED_UP unsigned short add16(unsigned short base,unsigned short adder);
SPEED_UP unsigned short sub16(unsigned short base,unsigned short subt);
SPEED_UP unsigned char sub8(unsigned char base,unsigned char subt);
SPEED_UP unsigned char add8(unsigned char base,unsigned char adder);

Code: Select all

void group_fe(){
    mod_rm rm[1];
    unsigned char *ptr;
    unsigned char *ptr2;
    unsigned char *to_be_used; //this is the contents of the interpreted modrm
    unsigned int tmp;
    ip++;
    MemRead8(CS,ip,rm); //store rm because we need 'extra'(sometimes)
    tmp=GetModRM_write8(&ptr); //note it isn't always write8 for each group!
    //pointer now contains the memory address that should be used(unless tmp==opcode_specific)
    if(tmp==0){ //is normal and ptr contains the memory address
        ptr=(unsigned long)ptr+(unsigned long)core;
        to_be_used=ptr;
    }
    if(tmp==OPCODE_SPECIFIC){
        to_be_used=gregs8[rm[0].rm];
    }
	//actually you can ignore above this line!
    //do opcode specific stuff...
    switch(rm[0].extra){ //check opcode
    	case 0: //inc modrm8
		//now you do your thing, except for instead of reg, you use *to_be_used;
		tmp=flags->cf;
		*to_be_used=add8(*to_be_used,1);
		flags->cf=tmp;
		//this one is inc!
		break;
		case 1: //dec modrm8
		//now you do your thing with dec, except for instead of reg, you use *to_be_used;
		//you fill out this one!

		//this one is dec!
		break;
        default:
        panic("Unsupported opcode! at rm\n");
        break;
    }

}

Code: Select all

tmp=GetModRM_write8(&ptr);

Code: Select all

mov [0xb8000], 12

Code: Select all

mov ax,0xB800
mov ds,ax
mov bx,0
mov [bx],byte 12

Code: Select all

inline unsigned char shr8(unsigned char op1,unsigned char op2) {
	unsigned char tmp_count = op2 & 0x1f;
	unsigned char tmp_dest = op1;
	
	while(tmp_count > 0) {
		op1 = op1 >> 1;
		unsigned char lsb = tmp_dest & 0x01;
		flags->cf = lsb;
		tmp_count--;
	}

	if(op2 == 1) {
		unsigned char msb = tmp_dest & 0x80;
		flags->of = msb;
	}
	
	CalculatePF8(op1); //this will set PF for you
	CalculateSF8(op1); //this will set SF for you
	if(op1==0){flags->zf=1;}else{flags->zf=0;}
	return op1;
}

inline unsigned short shr16(unsigned short op1,unsigned char op2) {
	unsigned char tmp_count = op2 & 0x1f;
	unsigned short tmp_dest = op1;
	
	while(tmp_count > 0) {
		op1 = op1 >> 1;
		unsigned char lsb = op1 & 0x01;
		flags->cf = lsb;
		tmp_count--;
	}

	if(tmp_count == 1) {
		unsigned short msb = tmp_dest & 0x8000;
		flags->of = msb;
	}
	CalculatePF16(op1); //this will set PF for you
	CalculateSF16(op1); //this will set SF for you
	if(op1==0){flags->zf=1;}else{flags->zf=0;}
	return op1;
}

Code: Select all

else if(bit_type == 16) 
					*to_be_used = shl16((unsigned short)*to_be_used, iw);[/code
does that work? does shl16 returning unsigned short, override the default type of to_be_used(which is unsigned char) otherwise it will still only write one byte rather than a word...

edit:
as far as next things to do..
there are the things like movs, and other string operations(already have cmps implemented) btw, no need to worry about rep stuff..
umm..immediant maths like
sub modrm16, imm16 
and add modrm16, imm16

as far as your shift stuff, I will probably move it to a different file..(it will be in bitwise.c)

edit2:
Could you please provide the InstallOp things for that group..I'm not for sure if it takes from C0 to D0 or what..?

Code: Select all

	  InstallOp(0xC0,group_c0_through_d3);	
	  InstallOp(0xC1,group_c0_through_d3);
	  InstallOp(0xD0,group_c0_through_d3);
	  InstallOp(0xD1,group_c0_through_d3);
	  InstallOp(0xD2,group_c0_through_d3);
	  InstallOp(0xD3,group_c0_through_d3);