如何在 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

考虑到已接受的答案及其评论，我会重新考虑 Jester 的建议（在我看来，与建议的 Z80 代码相比，这似乎只有 +4B，但代码布局略有不同，即 less/greater_equal 分支所在的位置，这可能会进一步复杂化或简化您的代码）代码...加上它应该比每次对 D 和 H 进行异或 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
    ...

您还可以将其修改为当 DE<HL 时返回 CF=1 的过程：

: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)

顺便说一句，你可以将 CF=0/1 转换为 A=0/~0 sbb a- 有时这0/255对于进一步计算很方便......

但正如我在问题下评论的那样，很多时候这值得在架构级别上重新审视，看看整个代码逻辑是否不能变成无符号 0..FFFF 操作模式，也许会导致调整（通过 -32768 ）诸如“_left”之类的值仅位于一个/两个特定点（如最终输出给用户），而更多其他内部比较/用法将以无符号方式工作。

编辑：

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

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 常量的 reg-pair：

; 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)
    ...