如何有效地对 8080 进行符号比较？

Question

我想比较两个 16 位数字并根据结果进行分支：等价于 if (a<b) goto negative。我使用的是英特尔 8080。

Z80 有一个带符号的算术溢出标志，可以在一定程度上用于此目的。标准代码为：

ld de, _left
ld hl, _right
ld a, e
sub a, l
ld a, d
sbc a, h
jp po, $+5  ; branch on overflow flag not set
xor a, 0x80 ; flip sign bit
jm negative ; actually do the test

但是 8080 不是 Z80 的严格子集，上面的代码在那里不起作用 --- 在 8080 上，算术指令根据结果的奇偶性设置 P 标志，搞笑结果。

那么在 8080 上进行带符号比较的惯用方法是什么？

实际上可以计算溢出标志，但真的很痛苦，因为它需要对操作数和结果进行位操作，而且我运行寄存器用完了。而且，这实际上不是我想要的；我实际上并不关心溢出。我只是想做个比较。

（如果结果为负，我不能简单地减去和分支，因为这在所有情况下都不起作用。考虑 INT_MIN < INT_MAX。那是 0x8000 - 0x7fff = 1，这显然是积极的。）

Answer 1

在 8085 上有两个 undocumented flags K and V 用于带符号的比较和带符号的溢出，以及未记录的指令 JK/JNK 用于跳转带符号的小于 than/larger than

What undocumented 8085 instructions is Steven Morse referring to in "In The Beginning"?
What is the purpose of the reserved/undefined bit in the flag register?

不确定它们在 8080 上是否可用。但如果他们不这样做，您可以通过切换最高位

bool signedCmp(int a, int b)
{
    return unsignedCmp(a ^ INT_MIN, b ^ INT_MIN);
}

我不知道 8080 汇编，但也许类似这样的东西可以用来比较 DE 和 HL

mov a, e
sub a, l     ; e - l
mov a, h
xri a, 0x80
mov h, a     ; h ^= 0x80
mov a, d
xri a, 0x80  ; a = d ^ 0x80
sbb a, h     ; d - h
jc lessthan  ; branch on carry
    ; >= case
:lessthan
    ; < case

Answer 2

考虑到已接受的答案及其评论，我会重新考虑 Jester 的建议（在我看来，与提议的 Z80 代码相比，这似乎只有 +4B，但代码布局略有不同，即 less/greater_equal 分支所在的位置，这可能会使您的代码进一步复杂化或简化......而且它应该比每次对 D 和 H 执行 xor 0x80 执行得更好）：

    mov     a,d
    xra     h
    jp      sameSigns   ; as "JNS" in 8086 / "jp p," in Z80
    ; sign bits are different, signed overflow may happen
    ; but if H positive, then DE is less than HL
    xra     d           ; make A=H and set sign flag
    jm      DeIsGreaterEqualThanHl
:DeIsLessThanHl
    ; DE < HL
    ...

:sameSigns
    ; sign bits are equal, it is safe to do ordinary sub
    mov     a,e
    sub     l
    mov     a,d
    sbb     h
    jc      DeIsLessThanHl
:DeIsGreaterEqualThanHl
    ; DE >= HL
    ...

您也可以将其修改为程序 which returns CF=1 when DE

:SignedCmpDeHl
    mov     a,d
    xra     h
    jp      sameSigns   ; as "JNS" in 8086 / "jp p," in Z80
    ; sign bits are different, signed overflow may happen
    ; but if H positive, then DE is less than HL
    xra     d           ; make A=H and set sign flag (CF=0)
    rm                  ; return CF=0 when DE >= HL (H is negative)
    stc
    ret                 ; return CF=1 when DE < HL (H is positive/zero)
:sameSigns
    ; sign bits are equal, it is safe to do ordinary sub
    mov     a,e
    sub     l
    mov     a,d
    sbb     h
    ret                 ; return with CF=1 when DE < HL (CF=0 DE >= HL)

顺便说一句，您可以通过 sbb a 将 CF=0/1 变成 A=0/~0 - 有时 0/255 对进一步计算很方便...

但正如我在问题下评论的那样，很多时候这在架构层面上值得重新审视，看看整个代码逻辑是否不能变成无符号 0..FFFF 操作模式，也许会导致调整（-32768）像“_left”这样的值只是在 one/two 特定点（比如最终输出给用户），而更多其他内部 comparisons/usages 将以无符号方式工作。

编辑：

用于与常量进行比较的一些变体（对于一次性常量，将其加载到其他 RP 并使用通用 RP1 与 RP2 进行比较可能更好（在大小方面），特别是如果您有备用 RP 和通用compare 已经为其他代码实例化了......但是对于同一常量的多次使用，这可能会在大小和速度方面都获胜......内联在速度方面获胜？可能与子例程相提并论，取决于结果如何被使用）。

reg-pair（实际上也是任何 8b reg）对零：

; signed compare 8b or 16b register vs 0, into SF, destroys A
    xra     a       ; A=0
    ora     R       ; 16b R=[HDB], or any 8b R: SF = (RP < 0 or R < 0)
    ...i.e. "jm hlIsLessThanZero"

; signed compare 8b or 16b register vs 0, into CF, destroys A
    mov     a,R     ; 16b R=[HDB], or any 8b R
    ral             ; CF = (RP < 0) or (R < 0)
    ...i.e. "jc hlIsLessThanZero" or "sbb a" to get 0/255

针对任何 16b #XY 常数的注册对：

; signed 16b compare RP (HL/DE/BC) vs nonzero constant #XY
; subroutine, returns CF=1 if RP < #XY, modifies A
    mov     a,R
    xri     0x80    ; convert 8000..7FFF into 0000..FFFF
    cpi     #X^0x80 ; "X" is xor-ed with 0x80 too to have it in 0000..FFFF range
    rnz             ; if ZF=0, then CF=1 is (RP < XY) and CF=0 is (RP > XY)
    ; R == X, the low 8b P vs Y will decide
    mov     a,P
    cpi     #Y      ; CF=1 if (RP < XY)
    ret             ; 10B for particular #XY constant and RP

; inlined form
    mov     a,R
    xri     0x80    ; convert 8000..7FFF into 0000..FFFF
    cpi     #X^0x80 ; "X" is xor-ed with 0x80 too to have it in 0000..FFFF range
    jnz     HiByteWasDecisive   ; if ZF=0, then CF is set correctly, done
    mov     a,P     ; R == #X, the low 8b P vs #Y will decide final CF
    cpi     #Y      ; CF=1 if (RP < #XY)
:HiByteWasDecisive
    ; CF=1 is (RP < #XY) and CF=0 is (RP >= #XY)
    ...

如何有效地对 8080 进行符号比较？

How do I efficiently do signed comparisons on the 8080?

comparison

assembly

signed

intel-8080