Z80 上的溢出和进位标志 [英] Overflow and Carry flags on Z80
问题描述
我已经开始在我的 Z80 内核上实现 ADD A,r 操作码集.我对进位和溢出标志有点困惑，我认为我已经确定了，但我想把它提交给社区以检查我是否正确.
I have gotten round to implementing the ADD A,r set of opcodes on my Z80 core. I had a bit of confusion about the carry and overflow flags which I think I've nailed, but I wanted to put it to the community to check that I'm right.
基本上，据我所知，Z80 中的 ALU 不关心有符号/无符号操作，它只是添加位.这意味着如果两个 8 位值相加并导致 9 位值作为它们相加的结果，则进位标志将被设置.这包括将两个负的二进制补码相加，例如 -20 (11101100) 和 -40 (11011000)，虽然结果是 -60 (11000100)，但结果实际上是一个 9 位值 1 1100 0100.这肯定意味着如果添加两个负的二进制补码值，即使没有溢出条件，进位标志也将始终被设置 - 我对吗?
Basically, from what I can see, the ALU in the Z80 doesn't care about signed/unsigned operations, it just adds bits. This means that if two 8-bit values are added together and cause a 9-bit value as a result of their addition, the carry flag will be set. This includes adding two negative two's complement numbers, for example -20 (11101100) and -40 (11011000), as although the result is -60 (11000100), the result is actually a 9-bit value 1 1100 0100. This surely means if adding two negative two's complement values, the carry flag will always be set, even when there is no overflow condition - am I right?
其次，我决定检测这条指令的溢出，我会对两个操作数的第 7 位进行异或，如果结果是 10000000，那么肯定没有溢出 - 如果这个结果是 00000000 那么可能有溢出，因为符号相同，因此我会将加法结果的第 7 位与任一操作数的第 7 位进行异或，如果结果为 10000000，则发生溢出，我设置 P/V 溢出旗帜.我也在吗?
Secondly, I decided that to detect an overflow in this instruction, I would XOR bit 7 of both operands, and if the result was 10000000, then there is definitely no overflow - if the result of this is 00000000 then there could be an overflow as the signs are the same, and I would therefore XOR bit 7 of the result of the addition with bit 7 of either operand, and if the result of this is 10000000 then an overflow has occurred and I set the P/V overflow flag. Am I right here also?
抱歉问了这么复杂的问题，我很确定我是对的，但在我继续基于此逻辑进行无数更多指令之前，我需要知道.非常感谢.
Sorry for such a convoluted question, I'm pretty sure I'm right but I need to know before I carry on with countless more instructions based on this logic. Many thanks.
推荐答案
结果的位是从无符号整数的截断总和中获得的.add 指令不关心这里的符号，也不关心你自己对有符号或无符号整数的解释.它只是添加，好像数字是无符号的.
The bits of the result are obtained from the truncated sum of unsigned integers. The add instruction doesn't care about the sign here nor does it care about your own interpretation of the integers as signed or unsigned. It just adds as if the numbers were unsigned.
进位标志(或减法情况下的借位)是 8 位无符号整数相加后不存在的第 9 位.实际上，此标志表示无符号整数的加/减的上溢/下溢.同样，add 根本不关心这里的符号，它只是像数字无符号一样添加.
The carry flag (or borrow in case of subtraction) is that non-existent 9th bit from the addition of the 8-bit unsigned integers. Effectively, this flag signifies an overflow/underflow for add/sub of unsigned integers. Again, add doesn't care about the signs here at all, it just adds as if the numbers were unsigned.
添加两个负 2 的补码将导致进位标志设置为 1，正确.
Adding two negative 2's complement numbers will result in setting of the carry flag to 1, correct.
溢出标志显示有符号整数的加/减是否存在上溢/下溢.为了设置溢出标志，指令将数字视为有符号数(就像它将进位标志和结果的 8 位的数字视为无符号数一样).
The overflow flag shows whether or not there's been an overflow/underflow for add/sub of signed integers. To set the overflow flag the instruction treats the numbers as signed (just like it treats them as unsigned for the carry flag and the 8 bits of the result).
设置溢出标志背后的想法很简单.假设您将 8 位有符号整数符号扩展为 9 位，也就是说，只需将第 7 位复制到额外的第 8 位.如果这些 9 位有符号整数的 9 位和/差在第 7 位和第 8 位中具有不同的值，则将发生上溢/下溢，这意味着加法/减法在第 7 位失去了结果的符号并将其用于结果的大小，或者换句话说，8位不能容纳符号位和这么大的大小.
The idea behind setting the overflow flag is simple. Suppose you sign-extend your 8-bit signed integers to 9 bits, that is, just copy the 7th bit to an extra, 8th bit. An overflow/underflow will occur if the 9-bit sum/difference of these 9-bit signed integers has different values in bits 7 and 8, meaning that the addition/subtraction has lost the result's sign in the 7th bit and used it for the result's magnitude, or, in other words, the 8 bits can't accommodate the sign bit and such a large magnitude.
现在，当且仅当第 7 位的进位和第 8 位的进位(=第 7 位的进位)不同时，结果的第 7 位与虚数符号位 8 不同.那是因为我们从具有第 7 位 = 第 8 位的加数开始，只有不同的进位才能以不同的方式影响它们的结果.
Now, bit 7 of the result can differ from the imaginary sign bit 8 if and only if the carry into bit 7 and the carry into bit 8 (=carry out of bit 7) are different. That's because we start with the addends having bit 7=bit 8 and only different carry-ins into them can affect them in the result in different ways.
所以溢出标志 = 进位标志 XOR 从第 6 位进位到第 7 位.
So overflow flag = carry-out flag XOR carry from bit 6 into bit 7.
我和你计算溢出标志的方法都是正确的.事实上，两者都在Z80 CPU 用户手册的Z80状态指示器标志".
Both my and your ways of calculating the overflow flag are correct. In fact, both are described in the Z80 CPU User's Manual in section "Z80 Status Indicator Flags".
以下是在 C 中模拟大部分 ADC 指令的方法，您无法直接访问 CPU 的标志，也无法充分利用模拟 CPU 的 ADC 指令:
Here's how you can emulate most of the ADC instruction in C, where you don't have direct access to the CPU's flags and can't take full advantage of the emulating CPU's ADC instruction:
#include <stdio.h>
#include <limits.h>
#if CHAR_BIT != 8
#error char expected to have exactly 8 bits.
#endif
typedef unsigned char uint8;
typedef signed char int8;
#define FLAGS_CY_SHIFT 0
#define FLAGS_OV_SHIFT 1
#define FLAGS_CY_MASK (1 << FLAGS_CY_SHIFT)
#define FLAGS_OV_MASK (1 << FLAGS_OV_SHIFT)
void Adc(uint8* acc, uint8 b, uint8* flags)
{
uint8 a = *acc;
uint8 carryIns;
uint8 carryOut;
// Calculate the carry-out depending on the carry-in and addends.
//
// carry-in = 0: carry-out = 1 IFF (a + b > 0xFF) or,
// equivalently, but avoiding overflow in C: (a > 0xFF - b).
//
// carry-in = 1: carry-out = 1 IFF (a + b + 1 > 0xFF) or,
// equivalently, (a + b >= 0xFF) or,
// equivalently, but avoiding overflow in C: (a >= 0xFF - b).
//
// Also calculate the sum bits.
if (*flags & FLAGS_CY_MASK)
{
carryOut = (a >= 0xFF - b);
*acc = a + b + 1;
}
else
{
carryOut = (a > 0xFF - b);
*acc = a + b;
}
#if 0
// Calculate the overflow by sign comparison.
carryIns = ((a ^ b) ^ 0x80) & 0x80;
if (carryIns) // if addend signs are the same
{
// overflow if the sum sign differs from the sign of either of addends
carryIns = ((*acc ^ a) & 0x80) != 0;
}
#else
// Calculate all carry-ins.
// Remembering that each bit of the sum =
// addend a's bit XOR addend b's bit XOR carry-in,
// we can work out all carry-ins from a, b and their sum.
carryIns = *acc ^ a ^ b;
// Calculate the overflow using the carry-out and
// most significant carry-in.
carryIns = (carryIns >> 7) ^ carryOut;
#endif
// Update flags.
*flags &= ~(FLAGS_CY_MASK | FLAGS_OV_MASK);
*flags |= (carryOut << FLAGS_CY_SHIFT) | (carryIns << FLAGS_OV_SHIFT);
}
void Sbb(uint8* acc, uint8 b, uint8* flags)
{
// a - b - c = a + ~b + 1 - c = a + ~b + !c
*flags ^= FLAGS_CY_MASK;
Adc(acc, ~b, flags);
*flags ^= FLAGS_CY_MASK;
}
const uint8 testData[] =
{
0,
1,
0x7F,
0x80,
0x81,
0xFF
};
int main(void)
{
unsigned aidx, bidx, c;
printf("ADC:
");
for (c = 0; c <= 1; c++)
for (aidx = 0; aidx < sizeof(testData)/sizeof(testData[0]); aidx++)
for (bidx = 0; bidx < sizeof(testData)/sizeof(testData[0]); bidx++)
{
uint8 a = testData[aidx];
uint8 b = testData[bidx];
uint8 flags = c << FLAGS_CY_SHIFT;
printf("%3d(%4d) + %3d(%4d) + %u = ",
a, (int8)a, b, (int8)b, c);
Adc(&a, b, &flags);
printf("%3d(%4d) CY=%d OV=%d
",
a, (int8)a, (flags & FLAGS_CY_MASK) != 0, (flags & FLAGS_OV_MASK) != 0);
}
printf("SBB:
");
for (c = 0; c <= 1; c++)
for (aidx = 0; aidx < sizeof(testData)/sizeof(testData[0]); aidx++)
for (bidx = 0; bidx < sizeof(testData)/sizeof(testData[0]); bidx++)
{
uint8 a = testData[aidx];
uint8 b = testData[bidx];
uint8 flags = c << FLAGS_CY_SHIFT;
printf("%3d(%4d) - %3d(%4d) - %u = ",
a, (int8)a, b, (int8)b, c);
Sbb(&a, b, &flags);
printf("%3d(%4d) CY=%d OV=%d
",
a, (int8)a, (flags & FLAGS_CY_MASK) != 0, (flags & FLAGS_OV_MASK) != 0);
}
return 0;
}
输出:
ADC:
0( 0) + 0( 0) + 0 = 0( 0) CY=0 OV=0
0( 0) + 1( 1) + 0 = 1( 1) CY=0 OV=0
0( 0) + 127( 127) + 0 = 127( 127) CY=0 OV=0
0( 0) + 128(-128) + 0 = 128(-128) CY=0 OV=0
0( 0) + 129(-127) + 0 = 129(-127) CY=0 OV=0
0( 0) + 255( -1) + 0 = 255( -1) CY=0 OV=0
1( 1) + 0( 0) + 0 = 1( 1) CY=0 OV=0
1( 1) + 1( 1) + 0 = 2( 2) CY=0 OV=0
1( 1) + 127( 127) + 0 = 128(-128) CY=0 OV=1
1( 1) + 128(-128) + 0 = 129(-127) CY=0 OV=0
1( 1) + 129(-127) + 0 = 130(-126) CY=0 OV=0
1( 1) + 255( -1) + 0 = 0( 0) CY=1 OV=0
127( 127) + 0( 0) + 0 = 127( 127) CY=0 OV=0
127( 127) + 1( 1) + 0 = 128(-128) CY=0 OV=1
127( 127) + 127( 127) + 0 = 254( -2) CY=0 OV=1
127( 127) + 128(-128) + 0 = 255( -1) CY=0 OV=0
127( 127) + 129(-127) + 0 = 0( 0) CY=1 OV=0
127( 127) + 255( -1) + 0 = 126( 126) CY=1 OV=0
128(-128) + 0( 0) + 0 = 128(-128) CY=0 OV=0
128(-128) + 1( 1) + 0 = 129(-127) CY=0 OV=0
128(-128) + 127( 127) + 0 = 255( -1) CY=0 OV=0
128(-128) + 128(-128) + 0 = 0( 0) CY=1 OV=1
128(-128) + 129(-127) + 0 = 1( 1) CY=1 OV=1
128(-128) + 255( -1) + 0 = 127( 127) CY=1 OV=1
129(-127) + 0( 0) + 0 = 129(-127) CY=0 OV=0
129(-127) + 1( 1) + 0 = 130(-126) CY=0 OV=0
129(-127) + 127( 127) + 0 = 0( 0) CY=1 OV=0
129(-127) + 128(-128) + 0 = 1( 1) CY=1 OV=1
129(-127) + 129(-127) + 0 = 2( 2) CY=1 OV=1
129(-127) + 255( -1) + 0 = 128(-128) CY=1 OV=0
255( -1) + 0( 0) + 0 = 255( -1) CY=0 OV=0
255( -1) + 1( 1) + 0 = 0( 0) CY=1 OV=0
255( -1) + 127( 127) + 0 = 126( 126) CY=1 OV=0
255( -1) + 128(-128) + 0 = 127( 127) CY=1 OV=1
255( -1) + 129(-127) + 0 = 128(-128) CY=1 OV=0
255( -1) + 255( -1) + 0 = 254( -2) CY=1 OV=0
0( 0) + 0( 0) + 1 = 1( 1) CY=0 OV=0
0( 0) + 1( 1) + 1 = 2( 2) CY=0 OV=0
0( 0) + 127( 127) + 1 = 128(-128) CY=0 OV=1
0( 0) + 128(-128) + 1 = 129(-127) CY=0 OV=0
0( 0) + 129(-127) + 1 = 130(-126) CY=0 OV=0
0( 0) + 255( -1) + 1 = 0( 0) CY=1 OV=0
1( 1) + 0( 0) + 1 = 2( 2) CY=0 OV=0
1( 1) + 1( 1) + 1 = 3( 3) CY=0 OV=0
1( 1) + 127( 127) + 1 = 129(-127) CY=0 OV=1
1( 1) + 128(-128) + 1 = 130(-126) CY=0 OV=0
1( 1) + 129(-127) + 1 = 131(-125) CY=0 OV=0
1( 1) + 255( -1) + 1 = 1( 1) CY=1 OV=0
127( 127) + 0( 0) + 1 = 128(-128) CY=0 OV=1
127( 127) + 1( 1) + 1 = 129(-127) CY=0 OV=1
127( 127) + 127( 127) + 1 = 255( -1) CY=0 OV=1
127( 127) + 128(-128) + 1 = 0( 0) CY=1 OV=0
127( 127) + 129(-127) + 1 = 1( 1) CY=1 OV=0
127( 127) + 255( -1) + 1 = 127( 127) CY=1 OV=0
128(-128) + 0( 0) + 1 = 129(-127) CY=0 OV=0
128(-128) + 1( 1) + 1 = 130(-126) CY=0 OV=0
128(-128) + 127( 127) + 1 = 0( 0) CY=1 OV=0
128(-128) + 128(-128) + 1 = 1( 1) CY=1 OV=1
128(-128) + 129(-127) + 1 = 2( 2) CY=1 OV=1
128(-128) + 255( -1) + 1 = 128(-128) CY=1 OV=0
129(-127) + 0( 0) + 1 = 130(-126) CY=0 OV=0
129(-127) + 1( 1) + 1 = 131(-125) CY=0 OV=0
129(-127) + 127( 127) + 1 = 1( 1) CY=1 OV=0
129(-127) + 128(-128) + 1 = 2( 2) CY=1 OV=1
129(-127) + 129(-127) + 1 = 3( 3) CY=1 OV=1
129(-127) + 255( -1) + 1 = 129(-127) CY=1 OV=0
255( -1) + 0( 0) + 1 = 0( 0) CY=1 OV=0
255( -1) + 1( 1) + 1 = 1( 1) CY=1 OV=0
255( -1) + 127( 127) + 1 = 127( 127) CY=1 OV=0
255( -1) + 128(-128) + 1 = 128(-128) CY=1 OV=0
255( -1) + 129(-127) + 1 = 129(-127) CY=1 OV=0
255( -1) + 255( -1) + 1 = 255( -1) CY=1 OV=0
SBB:
0( 0) - 0( 0) - 0 = 0( 0) CY=0 OV=0
0( 0) - 1( 1) - 0 = 255( -1) CY=1 OV=0
0( 0) - 127( 127) - 0 = 129(-127) CY=1 OV=0
0( 0) - 128(-128) - 0 = 128(-128) CY=1 OV=1
0( 0) - 129(-127) - 0 = 127( 127) CY=1 OV=0
0( 0) - 255( -1) - 0 = 1( 1) CY=1 OV=0
1( 1) - 0( 0) - 0 = 1( 1) CY=0 OV=0
1( 1) - 1( 1) - 0 = 0( 0) CY=0 OV=0
1( 1) - 127( 127) - 0 = 130(-126) CY=1 OV=0
1( 1) - 128(-128) - 0 = 129(-127) CY=1 OV=1
1( 1) - 129(-127) - 0 = 128(-128) CY=1 OV=1
1( 1) - 255( -1) - 0 = 2( 2) CY=1 OV=0
127( 127) - 0( 0) - 0 = 127( 127) CY=0 OV=0
127( 127) - 1( 1) - 0 = 126( 126) CY=0 OV=0
127( 127) - 127( 127) - 0 = 0( 0) CY=0 OV=0
127( 127) - 128(-128) - 0 = 255( -1) CY=1 OV=1
127( 127) - 129(-127) - 0 = 254( -2) CY=1 OV=1
127( 127) - 255( -1) - 0 = 128(-128) CY=1 OV=1
128(-128) - 0( 0) - 0 = 128(-128) CY=0 OV=0
128(-128) - 1( 1) - 0 = 127( 127) CY=0 OV=1
128(-128) - 127( 127) - 0 = 1( 1) CY=0 OV=1
128(-128) - 128(-128) - 0 = 0( 0) CY=0 OV=0
128(-128) - 129(-127) - 0 = 255( -1) CY=1 OV=0
128(-128) - 255( -1) - 0 = 129(-127) CY=1 OV=0
129(-127) - 0( 0) - 0 = 129(-127) CY=0 OV=0
129(-127) - 1( 1) - 0 = 128(-128) CY=0 OV=0
129(-127) - 127( 127) - 0 = 2( 2) CY=0 OV=1
129(-127) - 128(-128) - 0 = 1( 1) CY=0 OV=0
129(-127) - 129(-127) - 0 = 0( 0) CY=0 OV=0
129(-127) - 255( -1) - 0 = 130(-126) CY=1 OV=0
255( -1) - 0( 0) - 0 = 255( -1) CY=0 OV=0
255( -1) - 1( 1) - 0 = 254( -2) CY=0 OV=0
255( -1) - 127( 127) - 0 = 128(-128) CY=0 OV=0
255( -1) - 128(-128) - 0 = 127( 127) CY=0 OV=0
255( -1) - 129(-127) - 0 = 126( 126) CY=0 OV=0
255( -1) - 255( -1) - 0 = 0( 0) CY=0 OV=0
0( 0) - 0( 0) - 1 = 255( -1) CY=1 OV=0
0( 0) - 1( 1) - 1 = 254( -2) CY=1 OV=0
0( 0) - 127( 127) - 1 = 128(-128) CY=1 OV=0
0( 0) - 128(-128) - 1 = 127( 127) CY=1 OV=0
0( 0) - 129(-127) - 1 = 126( 126) CY=1 OV=0
0( 0) - 255( -1) - 1 = 0( 0) CY=1 OV=0
1( 1) - 0( 0) - 1 = 0( 0) CY=0 OV=0
1( 1) - 1( 1) - 1 = 255( -1) CY=1 OV=0
1( 1) - 127( 127) - 1 = 129(-127) CY=1 OV=0
1( 1) - 128(-128) - 1 = 128(-128) CY=1 OV=1
1( 1) - 129(-127) - 1 = 127( 127) CY=1 OV=0
1( 1) - 255( -1) - 1 = 1( 1) CY=1 OV=0
127( 127) - 0( 0) - 1 = 126( 126) CY=0 OV=0
127( 127) - 1( 1) - 1 = 125( 125) CY=0 OV=0
127( 127) - 127( 127) - 1 = 255( -1) CY=1 OV=0
127( 127) - 128(-128) - 1 = 254( -2) CY=1 OV=1
127( 127) - 129(-127) - 1 = 253( -3) CY=1 OV=1
127( 127) - 255( -1) - 1 = 127( 127) CY=1 OV=0
128(-128) - 0( 0) - 1 = 127( 127) CY=0 OV=1
128(-128) - 1( 1) - 1 = 126( 126) CY=0 OV=1
128(-128) - 127( 127) - 1 = 0( 0) CY=0 OV=1
128(-128) - 128(-128) - 1 = 255( -1) CY=1 OV=0
128(-128) - 129(-127) - 1 = 254( -2) CY=1 OV=0
128(-128) - 255( -1) - 1 = 128(-128) CY=1 OV=0
129(-127) - 0( 0) - 1 = 128(-128) CY=0 OV=0
129(-127) - 1( 1) - 1 = 127( 127) CY=0 OV=1
129(-127) - 127( 127) - 1 = 1( 1) CY=0 OV=1
129(-127) - 128(-128) - 1 = 0( 0) CY=0 OV=0
129(-127) - 129(-127) - 1 = 255( -1) CY=1 OV=0
129(-127) - 255( -1) - 1 = 129(-127) CY=1 OV=0
255( -1) - 0( 0) - 1 = 254( -2) CY=0 OV=0
255( -1) - 1( 1) - 1 = 253( -3) CY=0 OV=0
255( -1) - 127( 127) - 1 = 127( 127) CY=0 OV=1
255( -1) - 128(-128) - 1 = 126( 126) CY=0 OV=0
255( -1) - 129(-127) - 1 = 125( 125) CY=0 OV=0
255( -1) - 255( -1) - 1 = 255( -1) CY=1 OV=0
您可以将 #if 0 更改为 #if 1 以使用基于符号比较的方法进行溢出计算.结果将是相同的.乍一看，基于符号的方法也会处理进位，这有点令人惊讶.
You can change #if 0 to #if 1 to use the sign-comparison-based method for overflow calculation. The result will be the same. At first glance it's a bit surprising that the sign-based method takes care of the carry-in too.
请注意，通过使用我将所有进位计算到第 0 位到第 7 位的方法，您还可以免费获得 half-carry 标志的值(从第 3 位进位到DAA 指令所需的位 4).
Please note that by using my method in which I calculate all carry-ins into bits 0 through 7, you also get for free the value of the half-carry flag (carry from bit 3 to bit 4) that's needed for the DAA instruction.
我添加了一个借用减法函数(SBC/SBB 指令)及其结果.
I've added a function for subtraction with borrow (SBC/SBB instruction) and results for it.
这篇关于Z80 上的溢出和进位标志的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
