Fixing UniPCemu's (I)MUL flags to be accurate? \ VOGONS

Fixing UniPCemu's (I)MUL flags to be accurate?

Topic actions

Post a reply

First post, by superfury

Posted on 2016-11-19, 10:56

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5465
Joined: 2014-03-08, 11:25
Location: Netherlands

I'm trying to get the (I)MUL test to pass it's flags test, but for some reason it won't give the correct results.

Different MUL instructions:
80186+ IMUL:

1void CPU186_OP69()
2{
3	if (modrm_check16(&params,1,1)) return; //Abort on fault!
4	temp1.val32 = modrm_read16(&params,1);
5	temp2.val32 = immw;
6	modrm_decode16(&params,&info,0);
7	debugger_setcommand("IMUL %s,%04X",info.text,temp2);
8	if ((temp1.val32 &0x8000)==0x8000) temp1.val32 |= 0xFFFF0000;
9	if ((temp2.val32 &0x8000)==0x8000) temp2.val32 |= 0xFFFF0000;
10	temp3.val32 = ((temp1.val32*temp2.val32)&0xFFFFFFFF);
11	REG_AX = temp3.val16;
12	REG_DX = temp3.val16high;
13	if (((temp1.val32>>15)==0) || ((temp1.val32>>15)==0x1FFFF)) FLAGW_OF(0);
14	else FLAGW_OF(1);
15	FLAGW_CF(FLAG_OF); //OF=CF!
16}

8086 MULB:

1	case 4: //MULB
2		tempAL = REG_AL; //Save a backup for calculating cycles!
3		temp1.val32 = (uint32_t)oper1b * (uint32_t)REG_AL;
4		REG_AX = temp1.val16 & 0xFFFF;
5		if (((temp1.val16&0xFF80)==0) || ((temp1.val16&0xFF80)==0xFF80))
6		{
7			FLAGW_OF(0); //Both zeroed!
8		}
9		else FLAGW_OF(1); //Set due to overflow!
10
11		FLAGW_CF(FLAG_OF); //Same!
12		tempAL = FLAG_ZF; //Backup!
13		flag_szp8(REG_AL);
14		if (EMULATED_CPU==CPU_8086) //8086 only?
15		{
16			FLAGW_ZF(tempAL); //Restore Zero flag!
17			if (REG_AX) FLAGW_ZF(0); //8086/8088 clears the Zero flag when not zero only. Undocumented bug!
18		}
19		if (MODRM_EA(params)) //Memory?
20		{
21			CPU[activeCPU].cycles_OP = 76+MODRM_EA(params); //Mem max!
22		}
23		else //Register?
24		{
25			CPU[activeCPU].cycles_OP = 70; //Reg!
26		}
27		if (NumberOfSetBits(tempAL)>1) //More than 1 bit set?
28		{
29			CPU[activeCPU].cycles_OP += NumberOfSetBits(tempAL) - 1; //1 cycle for all bits more than 1 bit set!
30		}
31		break;

8086 IMULB:

1	case 5: //IMULB
2		oper1 = oper1b;
3		temp1.val32 = REG_AL;
4		temp2.val32 = oper1b;
5		//Sign extend!
6		if ((temp1.val8 & 0x80) == 0x80) temp1.val32 |= 0xFFFFFF00;
7		if ((temp2.val8 & 0x80) == 0x80) temp2.val32 |= 0xFFFFFF00;
8		//Multiply and convert to 16-bit!
9		temp3.val32s = temp1.val32s; //Load and...
10		temp3.val32s *= temp2.val32s; //Multiply!
11		REG_AX = temp3.val16; //Load into AX!
12		if (((temp1.val16&0xFF80)==0) || ((temp1.val16&0xFF80)==0xFF80))
13		{
14			FLAGW_OF(0); //Both zeroed!
15		}
16		else FLAGW_OF(1); //Set due to overflow!
17
18		FLAGW_CF(FLAG_OF); //Same!
19		if (EMULATED_CPU==CPU_8086)
20		{
21			FLAGW_ZF(0); //Clear ZF!
22		}
23		if (MODRM_EA(params)) //Memory?
24		{
25			CPU[activeCPU].cycles_OP = 86 + MODRM_EA(params); //Mem max!
26		}
27		else //Register?
28		{
29			CPU[activeCPU].cycles_OP = 80; //Reg!
30		}
31		break;

8086 MULW:

1	case 4: //MULW
2		tempAX = REG_AX; //Save a backup for calculating cycles!
3		temp1.val32 = (uint32_t)oper1 * (uint32_t)REG_AX;
4		REG_AX = temp1.val16;
5		REG_DX = temp1.val16high;
6		if (((temp1.val32>>15)==0) || ((temp1.val32>>15)==0x1FFFF)) FLAGW_OF(0);
7		else FLAGW_OF(1);
8		FLAGW_CF(FLAG_OF); //OF=CF!
9
10		tempAL = FLAG_ZF; //Backup!
11		flag_szp16(REG_AX);
12		if (EMULATED_CPU==CPU_8086)
13		{
14			FLAGW_ZF(tempAL); //Restore!
15			if ((EMULATED_CPU==CPU_8086) && temp1.val32) FLAGW_ZF(0); //8086/8088 clears the Zero flag when not zero only.
16		}
17		if (MODRM_EA(params)) //Memory?
18		{
19			CPU[activeCPU].cycles_OP = 124 + MODRM_EA(params); //Mem max!
20		}
21		else //Register?
22		{
23			CPU[activeCPU].cycles_OP = 118; //Reg!
24		}
25		if (NumberOfSetBits(tempAX)>1) //More than 1 bit set?
26		{
27			CPU[activeCPU].cycles_OP += NumberOfSetBits(tempAX) - 1; //1 cycle for all bits more than 1 bit set!
28		}
29		break;

8086 IMULW:

1	case 5: //IMULW
2		temp1.val32 = REG_AX;
3		temp2.val32 = oper1;
4		//Sign extend!
5		if (temp1.val16 & 0x8000) temp1.val32 |= 0xFFFF0000;
6		if (temp2.val16 & 0x8000) temp2.val32 |= 0xFFFF0000;
7		temp3.val32s = temp1.val32s; //Load and...
8		temp3.val32s *= temp2.val32s; //Signed multiplication!
9		REG_AX = temp3.val16; //into register ax
10		REG_DX = temp3.val16high; //into register dx
11		if (((temp1.val32>>15)==0) || ((temp1.val32>>15)==0x1FFFF)) FLAGW_OF(0);
12		else FLAGW_OF(1);
13		FLAGW_CF(FLAG_OF); //OF=CF!
14		if (EMULATED_CPU==CPU_8086)
15		{
16			FLAGW_ZF(0); //Clear ZF!
17		}
18		if (MODRM_EA(params)) //Memory?
19		{
20			CPU[activeCPU].cycles_OP = 128 + MODRM_EA(params); //Mem max!
21		}
22		else //Register?
23		{
24			CPU[activeCPU].cycles_OP = 134; //Reg max!
25		}
26		break;

I'm getting the strangest flag errors, as can be seen in the log within the ZIP file(there's two files: debugger.log contains the disassembly, ROM_log.log contains the surrounding wrapper test results).

Filename: ROM_log_20161119_1153.zip
File size: 15.19 KiB
Downloads: 39 downloads
File comment: Logs of the testing MUL&arithmetic tests.
File license: Fair use/fair dealing exception

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Reply 1 of 12, by superfury

Posted on 2016-11-20, 16:02

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5465
Joined: 2014-03-08, 11:25
Location: Netherlands

I've managed to get the invalid list smaller by rewriting some instruction checks and fixing one instruction I've missed on the 80186+ emulation:

First 80186+ IMUL instruction:

1void CPU186_OP69()
2{
3	if (modrm_check16(&params,1,1)) return; //Abort on fault!
4	temp1.val32 = modrm_read16(&params,1);
5	temp2.val32 = immw;
6	modrm_decode16(&params,&info,0);
7	debugger_setcommand("IMULW %s,%04X",info.text,temp2);
8	if ((temp1.val32 &0x8000)==0x8000) temp1.val32 |= 0xFFFF0000;
9	if ((temp2.val32 &0x8000)==0x8000) temp2.val32 |= 0xFFFF0000;
10	temp3.val32s = temp1.val32s; //Load and...
11	temp3.val32s *= temp2.val32s; //Signed multiplication!
12	REG_AX = temp3.val16;
13	REG_DX = temp3.val16high;
14	if (((temp1.val32>>15)==0) || ((temp1.val32>>15)==0x1FFFF)) FLAGW_OF(0);
15	else FLAGW_OF(1);
16	FLAGW_CF(FLAG_OF); //OF=CF!
17}

Second 80186+ IMUL instruction:

1void CPU186_OP6B()
2{
3	if (modrm_check16(&params,1,1)) return; //Abort on fault!
4	temp1.val32 = (uint_32)modrm_read16(&params,1); //Read R/M!
5	temp2.val32 = (uint_32)immb; //Read unsigned parameter!
6	modrm_decode16(&params,&info,1); //Store the address!
7	if (temp1.val32&0x8000) temp1.val32 |= 0xFFFF0000;//Sign extend to 32 bits!
8	if (temp2.val32&0x80) temp2.val32 |= 0xFFFFFF00; //Sign extend to 32 bits!
9	debugger_setcommand("IMULW %s,%02X",info.text,temp2.val32&0xFF); //Command!
10
11	temp3.val32s = temp1.val32s * temp2.val32s;
12	modrm_write16(&params,0, temp3.val16,0); //Write to register!
13	if (((temp1.val32>>15)==0) || ((temp1.val32>>15)==0x1FFFF)) FLAGW_OF(0); //Overflow occurred?
14	else FLAGW_OF(1);
15	FLAGW_CF(FLAG_OF); //Same!
16}

8086 (I)MULB (GRP3 8-bit Opcode):

1	case 4: //MULB
2		tempAL = REG_AL; //Save a backup for calculating cycles!
3		temp1.val32 = (uint32_t)oper1b * (uint32_t)REG_AL;
4		REG_AX = temp1.val16 & 0xFFFF;
5		if ((temp1.val16&0xFF00)==0)
6		{
7			FLAGW_OF(0); //Both zeroed!
8		}
9		else FLAGW_OF(1); //Set due to overflow!
10
11		FLAGW_CF(FLAG_OF); //Same!
12		tempAL = FLAG_ZF; //Backup!
13		flag_szp8(REG_AL);
14		if (EMULATED_CPU==CPU_8086) //8086 only?
15		{
16			FLAGW_ZF(tempAL); //Restore Zero flag!
17			if (REG_AX) FLAGW_ZF(0); //8086/8088 clears the Zero flag when not zero only. Undocumented bug!
18		}
19		if (MODRM_EA(params)) //Memory?
20		{
21			CPU[activeCPU].cycles_OP = 76+MODRM_EA(params); //Mem max!
22		}
23		else //Register?
24		{
25			CPU[activeCPU].cycles_OP = 70; //Reg!
26		}
27		if (NumberOfSetBits(tempAL)>1) //More than 1 bit set?
28		{
29			CPU[activeCPU].cycles_OP += NumberOfSetBits(tempAL) - 1; //1 cycle for all bits more than 1 bit set!
30		}
31		break;
32
33	case 5: //IMULB
34		oper1 = oper1b;
35		temp1.val32 = REG_AL;
36		temp2.val32 = oper1b;
37		//Sign extend!
38		if ((temp1.val8 & 0x80) == 0x80) temp1.val32 |= 0xFFFFFF00;
39		if ((temp2.val8 & 0x80) == 0x80) temp2.val32 |= 0xFFFFFF00;
40		//Multiply and convert to 16-bit!
41		temp3.val32s = temp1.val32s; //Load and...
42		temp3.val32s *= temp2.val32s; //Multiply!
43		REG_AX = temp3.val16; //Load into AX!
44		if (((temp1.val16&0xFF80)==0) || ((temp1.val16&0xFF80)==0xFF80))
45		{
46			FLAGW_OF(0); //Both zeroed!
47		}
48		else FLAGW_OF(1); //Set due to overflow!
49
50		FLAGW_CF(FLAG_OF); //Same!
51		if (EMULATED_CPU==CPU_8086)
52		{
53			FLAGW_ZF(0); //Clear ZF!
54		}
55		if (MODRM_EA(params)) //Memory?
56		{
57			CPU[activeCPU].cycles_OP = 86 + MODRM_EA(params); //Mem max!
58		}
59		else //Register?
60		{

…Show last 3 lines

61			CPU[activeCPU].cycles_OP = 80; //Reg!
62		}
63		break;

8086+ (I)MULW (8086 GRP3 16-bit opcode):

1	case 4: //MULW
2		tempAX = REG_AX; //Save a backup for calculating cycles!
3		temp1.val32 = (uint32_t)oper1 * (uint32_t)REG_AX;
4		REG_AX = temp1.val16;
5		REG_DX = temp1.val16high;
6		if (temp1.val16high==0) FLAGW_OF(0);
7		else FLAGW_OF(1);
8		FLAGW_CF(FLAG_OF); //OF=CF!
9
10		tempAL = FLAG_ZF; //Backup!
11		flag_szp16(REG_AX);
12		if (EMULATED_CPU==CPU_8086)
13		{
14			FLAGW_ZF(tempAL); //Restore!
15			if ((EMULATED_CPU==CPU_8086) && temp1.val32) FLAGW_ZF(0); //8086/8088 clears the Zero flag when not zero only.
16		}
17		if (MODRM_EA(params)) //Memory?
18		{
19			CPU[activeCPU].cycles_OP = 124 + MODRM_EA(params); //Mem max!
20		}
21		else //Register?
22		{
23			CPU[activeCPU].cycles_OP = 118; //Reg!
24		}
25		if (NumberOfSetBits(tempAX)>1) //More than 1 bit set?
26		{
27			CPU[activeCPU].cycles_OP += NumberOfSetBits(tempAX) - 1; //1 cycle for all bits more than 1 bit set!
28		}
29		break;
30	case 5: //IMULW
31		temp1.val32 = REG_AX;
32		temp2.val32 = oper1;
33		//Sign extend!
34		if (temp1.val16 & 0x8000) temp1.val32 |= 0xFFFF0000;
35		if (temp2.val16 & 0x8000) temp2.val32 |= 0xFFFF0000;
36		temp3.val32s = temp1.val32s; //Load and...
37		temp3.val32s *= temp2.val32s; //Signed multiplication!
38		REG_AX = temp3.val16; //into register ax
39		REG_DX = temp3.val16high; //into register dx
40		if (((temp1.val32>>15)==0) || ((temp1.val32>>15)==0x1FFFF)) FLAGW_OF(0);
41		else FLAGW_OF(1);
42		FLAGW_CF(FLAG_OF); //OF=CF!
43		if (EMULATED_CPU==CPU_8086)
44		{
45			FLAGW_ZF(0); //Clear ZF!
46		}
47		if (MODRM_EA(params)) //Memory?
48		{
49			CPU[activeCPU].cycles_OP = 128 + MODRM_EA(params); //Mem max!
50		}
51		else //Register?
52		{
53			CPU[activeCPU].cycles_OP = 134; //Reg max!
54		}
55		break;

The log has become somewhat smaller due to these changes.

Filename: ROM_log_20161120_1650.zip
File size: 15.65 KiB
Downloads: 31 downloads
File comment: Log of UniPCemu commit 2016/11/20 16:50
File license: Fair use/fair dealing exception

100:00:19:21.04394: START FLAG_OF VERIFICATION PROCEDURE!
200:00:19:22.09998: Start verifying ROM/debug/999.mul.bin!
300:00:19:71.02550: Starting verification ROM emulator...
400:00:19:98.02792: Emulator terminated OK.
500:00:19:99.00160: Verifying output...
600:00:20:00.06718: Error address: 00000090, expected: 03, in memory: 02
700:00:20:02.07564: Error address: 00000091, expected: 08, in memory: 00
800:00:20:09.05394: Error address: 00000092, expected: 46, in memory: 02
900:00:20:14.05076: Error address: 00000096, expected: 86, in memory: 02
1000:00:20:15.00306: Error address: 00000098, expected: 82, in memory: 02
1100:00:20:16.02850: Error address: 0000009A, expected: 83, in memory: 02
1200:00:20:19.00062: Error address: 0000009B, expected: 08, in memory: 00
1300:00:20:28.09922: Error address: 0000009C, expected: 87, in memory: 02
1400:00:20:31.03270: Error address: 0000009D, expected: 08, in memory: 00
1500:00:20:35.04660: Error address: 0000009E, expected: 46, in memory: 02
1600:00:20:38.00112: Error address: 000000A2, expected: 86, in memory: 02
1700:00:20:46.03968: ROM Success: 0...
1800:00:20:53.02670: ROM/debug/999.mul.bin has gone wrong!

Anyone can see what's going wrong?

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Reply 2 of 12, by superfury

Posted on 2016-11-20, 17:20

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5465
Joined: 2014-03-08, 11:25
Location: Netherlands

Eventually, I managed to make it give the full correct results(no errors in the resulting flags or calculated values in memory):

8086 (I)MULB(GRP3 8-bit):

1	case 4: //MULB
2		tempAL = REG_AL; //Save a backup for calculating cycles!
3		temp1.val32 = (uint32_t)oper1b * (uint32_t)REG_AL;
4		REG_AX = temp1.val16 & 0xFFFF;
5		if ((temp1.val16&0xFF00)==0)
6		{
7			FLAGW_OF(0); //Both zeroed!
8		}
9		else FLAGW_OF(1); //Set due to overflow!
10
11		FLAGW_CF(FLAG_OF); //Same!
12		tempAL = FLAG_ZF; //Backup!
13		flag_szp8(REG_AL);
14		if (EMULATED_CPU==CPU_8086) //8086 only?
15		{
16			FLAGW_ZF(tempAL); //Restore Zero flag!
17			if (REG_AX) FLAGW_ZF(0); //8086/8088 clears the Zero flag when not zero only. Undocumented bug!
18		}
19		if (MODRM_EA(params)) //Memory?
20		{
21			CPU[activeCPU].cycles_OP = 76+MODRM_EA(params); //Mem max!
22		}
23		else //Register?
24		{
25			CPU[activeCPU].cycles_OP = 70; //Reg!
26		}
27		if (NumberOfSetBits(tempAL)>1) //More than 1 bit set?
28		{
29			CPU[activeCPU].cycles_OP += NumberOfSetBits(tempAL) - 1; //1 cycle for all bits more than 1 bit set!
30		}
31		break;
32
33	case 5: //IMULB
34		oper1 = oper1b;
35		temp1.val32 = REG_AL;
36		temp2.val32 = oper1b;
37		//Sign extend!
38		if ((temp1.val8 & 0x80) == 0x80) temp1.val32 |= 0xFFFFFF00;
39		if ((temp2.val8 & 0x80) == 0x80) temp2.val32 |= 0xFFFFFF00;
40		//Multiply and convert to 16-bit!
41		temp3.val32s = temp1.val32s; //Load and...
42		temp3.val32s *= temp2.val32s; //Multiply!
43		REG_AX = temp3.val16; //Load into AX!
44		FLAGW_SF((temp3.val16&0x80)>>7); //Sign!
45		FLAGW_PF(parity[temp3.val16&0xFF]); //Parity flag!
46		if (((temp3.val16&0xFF80)==0) || ((temp3.val16&0xFF80)==0xFF80))
47		{
48			FLAGW_OF(0); //Both zeroed!
49		}
50		else FLAGW_OF(1); //Set due to overflow!
51
52		FLAGW_CF(FLAG_OF); //Same!
53		FLAGW_ZF((temp3.val16==0)?1:0); //Set the zero flag!
54		if (EMULATED_CPU==CPU_8086)
55		{
56			FLAGW_ZF(0); //Clear ZF!
57		}
58		if (MODRM_EA(params)) //Memory?
59		{
60			CPU[activeCPU].cycles_OP = 86 + MODRM_EA(params); //Mem max!

…Show last 7 lines

61		}
62		else //Register?
63		{
64			CPU[activeCPU].cycles_OP = 80; //Reg!
65		}
66		break;

8086 (I)MULW(GRP3 16-bit):

1	case 4: //MULW
2		tempAX = REG_AX; //Save a backup for calculating cycles!
3		temp1.val32 = (uint32_t)oper1 * (uint32_t)REG_AX;
4		REG_AX = temp1.val16;
5		REG_DX = temp1.val16high;
6		if (temp1.val16high==0) FLAGW_OF(0);
7		else FLAGW_OF(1);
8		FLAGW_CF(FLAG_OF); //OF=CF!
9
10		tempAL = FLAG_ZF; //Backup!
11		flag_szp16(REG_AX);
12		if (EMULATED_CPU==CPU_8086)
13		{
14			FLAGW_ZF(tempAL); //Restore!
15			if ((EMULATED_CPU==CPU_8086) && temp1.val32) FLAGW_ZF(0); //8086/8088 clears the Zero flag when not zero only.
16		}
17		if (MODRM_EA(params)) //Memory?
18		{
19			CPU[activeCPU].cycles_OP = 124 + MODRM_EA(params); //Mem max!
20		}
21		else //Register?
22		{
23			CPU[activeCPU].cycles_OP = 118; //Reg!
24		}
25		if (NumberOfSetBits(tempAX)>1) //More than 1 bit set?
26		{
27			CPU[activeCPU].cycles_OP += NumberOfSetBits(tempAX) - 1; //1 cycle for all bits more than 1 bit set!
28		}
29		break;
30	case 5: //IMULW
31		temp1.val32 = REG_AX;
32		temp2.val32 = oper1;
33		//Sign extend!
34		if (temp1.val16 & 0x8000) temp1.val32 |= 0xFFFF0000;
35		if (temp2.val16 & 0x8000) temp2.val32 |= 0xFFFF0000;
36		temp3.val32s = temp1.val32s; //Load and...
37		temp3.val32s *= temp2.val32s; //Signed multiplication!
38		REG_AX = temp3.val16; //into register ax
39		REG_DX = temp3.val16high; //into register dx
40		if (((temp3.val32>>15)==0) || ((temp3.val32>>15)==0x1FFFF)) FLAGW_OF(0);
41		else FLAGW_OF(1);
42		FLAGW_CF(FLAG_OF); //OF=CF!
43		FLAGW_SF((temp3.val32&0x80000000)>>31); //Sign!
44		FLAGW_PF(parity[temp3.val32&0xFF]); //Parity flag!
45		FLAGW_ZF((temp3.val32==0)?1:0); //Set the zero flag!
46		if (EMULATED_CPU==CPU_8086)
47		{
48			FLAGW_ZF(0); //Clear ZF!
49		}
50		if (MODRM_EA(params)) //Memory?
51		{
52			CPU[activeCPU].cycles_OP = 128 + MODRM_EA(params); //Mem max!
53		}
54		else //Register?
55		{
56			CPU[activeCPU].cycles_OP = 134; //Reg max!
57		}
58		break;

80186 IMULW:

1void CPU186_OP69()
2{
3	if (modrm_check16(&params,1,1)) return; //Abort on fault!
4	temp1.val32 = modrm_read16(&params,1);
5	temp2.val32 = immw;
6	modrm_decode16(&params,&info,0);
7	debugger_setcommand("IMULW %s,%04X",info.text,temp2);
8	if ((temp1.val32 &0x8000)==0x8000) temp1.val32 |= 0xFFFF0000;
9	if ((temp2.val32 &0x8000)==0x8000) temp2.val32 |= 0xFFFF0000;
10	temp3.val32s = temp1.val32s; //Load and...
11	temp3.val32s *= temp2.val32s; //Signed multiplication!
12	REG_AX = temp3.val16;
13	REG_DX = temp3.val16high;
14	if (((temp3.val32>>15)==0) || ((temp3.val32>>15)==0x1FFFF)) FLAGW_OF(0);
15	else FLAGW_OF(1);
16	FLAGW_CF(FLAG_OF); //OF=CF!
17	FLAGW_SF((temp3.val32&0x80000000)>>31); //Sign!
18	FLAGW_PF(parity[temp3.val32&0xFF]); //Parity flag!
19	FLAGW_ZF((temp3.val32==0)?1:0); //Set the zero flag!
20}
21
22void CPU186_OP6B()
23{
24	if (modrm_check16(&params,1,1)) return; //Abort on fault!
25	temp1.val32 = (uint_32)modrm_read16(&params,1); //Read R/M!
26	temp2.val32 = (uint_32)immb; //Read unsigned parameter!
27	modrm_decode16(&params,&info,1); //Store the address!
28	if (temp1.val32&0x8000) temp1.val32 |= 0xFFFF0000;//Sign extend to 32 bits!
29	if (temp2.val32&0x80) temp2.val32 |= 0xFFFFFF00; //Sign extend to 32 bits!
30	debugger_setcommand("IMULW %s,%02X",info.text,temp2.val32&0xFF); //Command!
31
32	temp3.val32s = temp1.val32s * temp2.val32s;
33	modrm_write16(&params,0, temp3.val16,0); //Write to register!
34	if (((temp3.val32>>7)==0) || ((temp3.val32>>7)==0x1FFFFFF)) FLAGW_OF(0); //Overflow occurred?
35	else FLAGW_OF(1);
36	FLAGW_CF(FLAG_OF); //Same!
37	FLAGW_SF((temp3.val16&0x8000)>>31); //Sign!
38	FLAGW_PF(parity[temp3.val32&0xFF]); //Parity flag!
39	FLAGW_ZF((temp3.val16==0)?1:0); //Set the zero flag!
40}

Anyone can verify this functionality?

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Reply 3 of 12, by vladstamate

Posted on 2016-11-20, 18:37

vladstamate Offline

Rank Oldbie

Rank: Oldbie
Posts: 967
Joined: 2015-08-23, 01:43

How did you get this ROM that tests different instructions? I am interested in something like this too.

YouTube channel: https://www.youtube.com/channel/UC7HbC_nq8t1S9l7qGYL0mTA
Collection: http://www.digiloguemuseum.com/index.html
Emulator: https://sites.google.com/site/capex86/
Raytracer: https://sites.google.com/site/opaqueraytracer/

Reply 4 of 12, by superfury

Posted on 2016-11-20, 20:11

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5465
Joined: 2014-03-08, 11:25
Location: Netherlands

I simply use the ROMs that are posted on a topic on the fake86 emulator.

It's the EPC 186 testsuite in this topic:
http://forum.osdev.org/viewtopic.php?f=13&t=23739&start=15
By Artlav.

Artlav wrote:
Nice work. […]
Show full quote
Nice work.

If you're interested, here is my collection of testsuites for EPC's 80186:
http://orbides.1gb.ru/80186_tests.zip
res_*.bin contains the results expected at the offset 0x0 when you run *.bin test placed as a BIOS.

Although, if you have win 3.0 booting these are a little late.

About the timing - do you want to get precise real-time experience or something?
You won't get away from CPU overuse without many tricks. There is nothing better then scheduling to free the CPU (like sleep(1);), but it's hard to predict the duration.
Best results will be with rdtsc and active waiting, but you're still subjected to task switching.
Why bother?

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Reply 5 of 12, by superfury

Posted on 2016-11-21, 09:42

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5465
Joined: 2014-03-08, 11:25
Location: Netherlands

There's also something strange about the 80186+ IMUL instructions(Opcodes 6B&69). The documentation says it uses two different forms(2-operand and 3-operand forms), but I can't find any indication which one is used when? Does this depend on the Mod bits of the ModR/M byte? So register(11b) is mapped to the two-operand version, while memory operands (00b, 01b, 10b) are mapped to the three-operand version? How does the CPU know which one it is?

Looking at https://courses.engr.illinois.edu/ece390/reso … es/opcodes.html seems to imply that the mod 3 version indeed only uses two parameters (RM as register and immediate byte/word), while the other variant uses the RM, register and immediate word?

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Reply 6 of 12, by superfury

Posted on 2016-11-21, 12:36

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5465
Joined: 2014-03-08, 11:25
Location: Netherlands

This is what I've made of the information said at http://x86.renejeschke.de/html/file_module_x86_id_138.html :

1void CPU186_OP69()
2{
3	if (MODRM_MOD(params.modrm)!=3) //Use R/M to calculate the result(Three-operand version)?
4	{
5		if (modrm_check16(&params,1,1)) return; //Abort on fault!
6		temp1.val32 = modrm_read16(&params,1); //Read R/M!
7	}
8	else
9	{
10		temp1.val32 = (uint_32)modrm_read16(&params,0); //Read reg instead! Word register = Word register * imm16!
11	}
12	temp2.val32 = immw; //Immediate word is second/third parameter!
13	modrm_decode16(&params,&info,0); //Reg!
14	modrm_decode16(&params,&info2,1); //Second parameter(R/M)!
15	if (MODRM_MOD(params.modrm)==3) //Two-operand version?
16	{
17		debugger_setcommand("IMULW %s,%04X",info.text,immw); //IMUL reg,imm16
18	}
19	else //Three-operand version?
20	{
21		debugger_setcommand("IMULW %s,%s,%04X",info.text,info2.text,immw); //IMUL reg,r/m16,imm16
22	}
23	if ((temp1.val32 &0x8000)==0x8000) temp1.val32 |= 0xFFFF0000;
24	if ((temp2.val32 &0x8000)==0x8000) temp2.val32 |= 0xFFFF0000;
25	temp3.val32s = temp1.val32s; //Load and...
26	temp3.val32s *= temp2.val32s; //Signed multiplication!
27	modrm_write16(&params,0,temp3.val16,0); //Write to the destination(register)!
28	if (((temp3.val32>>15)==0) || ((temp3.val32>>15)==0x1FFFF)) FLAGW_OF(0);
29	else FLAGW_OF(1);
30	FLAGW_CF(FLAG_OF); //OF=CF!
31	FLAGW_SF((temp3.val32&0x80000000)>>31); //Sign!
32	FLAGW_PF(parity[temp3.val32&0xFF]); //Parity flag!
33	FLAGW_ZF((temp3.val32==0)?1:0); //Set the zero flag!
34}
35
36void CPU186_OP6B()
37{
38	if (MODRM_MOD(params.modrm)!=3) //Use R/M to calculate the result(Three-operand version)?
39	{
40		if (modrm_check16(&params,1,1)) return; //Abort on fault!
41		temp1.val32 = modrm_read16(&params,1); //Read R/M!
42	}
43	else
44	{
45		temp1.val32 = (uint_32)modrm_read16(&params,0); //Read reg instead! Word register = Word register * imm8 sign extended!
46	}
47	temp2.val32 = (uint_32)immb; //Read unsigned parameter!
48	modrm_decode16(&params,&info,0); //Store the address!
49	modrm_decode16(&params,&info2,1); //Store the address(R/M)!
50	if (MODRM_MOD(params.modrm)==3) //Two-operand version?
51	{
52		debugger_setcommand("IMULW %s,%02X",info.text,immb); //IMUL reg,imm8
53	}
54	else //Three-operand version?
55	{
56		debugger_setcommand("IMULW %s,%s,%02X",info.text,info2.text,immb); //IMUL reg,r/m16,imm8
57	}
58
59	if (temp1.val32&0x8000) temp1.val32 |= 0xFFFF0000;//Sign extend to 32 bits!
60	if (temp2.val32&0x80) temp2.val32 |= 0xFFFFFF00; //Sign extend to 32 bits!

…Show last 9 lines

61	temp3.val32s = temp1.val32s * temp2.val32s;
62	modrm_write16(&params,0,temp3.val16,0); //Write to register!
63	if (((temp3.val32>>7)==0) || ((temp3.val32>>7)==0x1FFFFFF)) FLAGW_OF(0); //Overflow occurred?
64	else FLAGW_OF(1);
65	FLAGW_CF(FLAG_OF); //Same!
66	FLAGW_SF((temp3.val16&0x8000)>>31); //Sign!
67	FLAGW_PF(parity[temp3.val32&0xFF]); //Parity flag!
68	FLAGW_ZF((temp3.val16==0)?1:0); //Set the zero flag!
69}

Anyone can confirm this behaviour on a 186+ CPU?

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Reply 7 of 12, by vladstamate

Posted on 2016-11-22, 00:31

vladstamate Offline

Rank Oldbie

Rank: Oldbie
Posts: 967
Joined: 2015-08-23, 01:43

Oh those tests are great!! Thank you for the link!

Reply 8 of 12, by superfury

Posted on 2016-11-22, 15:37

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5465
Joined: 2014-03-08, 11:25
Location: Netherlands

I've just tested Wolfenstein 3D's wolf3d.exe(instead of the 8088 wolf8088.exe). It runs without problems (the 8088 version messes up graphics a bit, mainly menus and surrounding game areas). It only gives a red screen and hangs when I'm trying to quit Wolfenstein 3D back to the MS-DOS prompt. Is this correct behaviour on the 80286? (It's probably the demo version of the game, as trying to select other levels than level 1 gives me the message to buy the game?)

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Reply 9 of 12, by peterferrie

Posted on 2016-11-22, 19:46

peterferrie Offline

Rank Oldbie

Rank: Oldbie
Posts: 649
Joined: 2008-05-08, 21:54

The "two-operand" version is when one of the registers is AX. Then it looks like "IMUL CX, val" when it's really "IMUL AX, CX, val".
It's a disassembler artifact, not an actual separate CPU instruction.

Reply 10 of 12, by superfury

Posted on 2016-11-22, 20:20

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5465
Joined: 2014-03-08, 11:25
Location: Netherlands

So the instruction is always IMUL reg,modr/m,val, which is essentially "int reg=modr/m*signextend(val);" in C/C++? That two-operand version doesn't need to be implemented, just the three-operand version?

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Reply 11 of 12, by vladstamate

Posted on 2016-11-23, 21:00

vladstamate Offline

Rank Oldbie

Rank: Oldbie
Posts: 967
Joined: 2015-08-23, 01:43

superfury wrote:
I've just tested Wolfenstein 3D's wolf3d.exe(instead of the 8088 wolf8088.exe). It runs without problems (the 8088 version messes up graphics a bit, mainly menus and surrounding game areas). It only gives a red screen and hangs when I'm trying to quit Wolfenstein 3D back to the MS-DOS prompt. Is this correct behaviour on the 80286? (It's probably the demo version of the game, as trying to select other levels than level 1 gives me the message to buy the game?)

I doubt that is the correct behaviour. Is is possible that you are not hanged, but rather that you are not out of VGA graphics mode? In other words the command prompt could be alive and running just the display is wrong? You can type a command like "dir" and see if INT 13H gets called.

Reply 12 of 12, by superfury

Posted on 2016-11-24, 10:15

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5465
Joined: 2014-03-08, 11:25
Location: Netherlands

I've done what you said (typing DIR and pressing enter during the red screen). I then turned on the logging of the executed commands and notice that the hard disk BIOS (which resides at segment C600h(NO this isn't the VGA BIOS, since the VGA BIOS ROM is 24kB in size, so the hard disk BIOS is at C600:0000)). I see it's in the hard disk BIOS(AT ROM of the latest XT-IDE BIOS), reading port 7 and waiting for bit 7 to set(which doesn't seem to happen for some reason)? This is the DMA channel 3 counter? The hard disk BIOS shouldn't use ISA DMA, since it uses PCI Bus Mastering DMA(UDMA?) of the hard disk instead? The hard disk emulation is supposed to support polling mode only?

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Go to top of page Go to top of page

Back to PC Emulation

Main menu

Common searches