BITswap 组装程序

Question

%include "asm_io.inc"
segment .data
outmsg1 db    "Input Integer: ", 0
outmsg2 db    "After Operation": ", 0

segment .bss

input1  resd 1
input2  resd 1

segment .text
    global  asm_main
asm_main:
    enter 0,0
    pusha

    mov eax, outmsg1
    call print_string
    call read_int
    call print_nl
    dump_regs 1

    rol eax, 8
    rol ax, 8
    ror eax,8
    mov ebx, 0
    mov ebx, eax
    dump_regs 2

    popa
    mov eax, 0
    leave
    ret

给定上述汇编程序，它将最高值字节与给定整数的最低值字节交换。我试图弄清楚如何让它用最低价值的 BIT 交换最高价值的 BIT。

我有点卡住了，也许你能帮帮我

Answer 1

这个怎么样？输入在ecx 或您喜欢的任何其他寄存器中。

                   // initial state: ECX = A...B
ror ecx            // ECX = BA..., CF = B
bt ecx, 30         // ECX = BA..., CF = A
rcl ecx, 2         // ECX = ...AB, CF = A
ror ecx            // ECX = B...A

正如 Peter Cordes 所指出的，如果您正在优化性能，您可能需要像这样更改代码：

ror ecx
bt ecx, 30
adc ecx, ecx
adc ecx, ecx
ror ecx

这是因为 adc r,r 在现代微架构上的性能优于 rcl r,imm 或 rcl r。

Answer 2

如果它们不同，您只需切换这两个位。如果这两个位都被设置或都被清除，你不需要做任何事情：

%include "asm_io.inc"
segment .text
    global  asm_main
asm_main:
    enter 0,0
    pusha

    ; Test values, comment it as needed
;   mov eax, 0x00123400         ; Bit0 and Bit31 are cleared
    mov eax, 0x00123401         ; Bit0 is set, Bit 31 is cleared
;   mov eax, 0x80123400         ; Bit0 is cleared, Bit31 is set
;   mov eax, 0x80123401         ; Bit0 and Bit31 are set

    dump_regs 1

    bt eax, 0                   ; Copy the least significant bit into CF
    setc cl                     ; Copy CF into register CL
    bt eax, 31                  ; Copy the most significant bit into CF
    setc ch                     ; Copy CF into register CH
    cmp cl, ch                  ; Compare the bits
    je skip                     ; No operation, if they don't differ
    btc eax, 0                  ; Toggle the least significant bit
    btc eax, 31                 ; Toggle the most significant bit
    skip:

    dump_regs 2

    popa
    mov eax, 0
    leave
    ret

另一个想法是使用TEST并根据标志进行操作-优点：您不需要额外的寄存器：

%include "asm_io.inc"

segment .text
    global  asm_main
asm_main:
    enter 0,0
    pusha

    ; Test values, comment it as needed
;   mov eax, 0x00123400         ; ZF PF
    mov eax, 0x00123401         ; -  -
;   mov eax, 0x80123400         ; SF PF
;   mov eax, 0x80123401         ; SF


    test eax, 0x80000001

    dump_regs 1

    jns j1
    jnp skip
    j1:
    jz skip

    doit:                       ; Touch the bits if (SF & PF) or (!SF & !PF)
    btc eax, 0                  ; Toggle the least significant bit
    btc eax, 31                 ; Toggle the most significant bit
    skip:

    dump_regs 2

    popa
    mov eax, 0
    leave
    ret

Answer 3

使用临时寄存器（EFLAGS 除外）在没有单周期的 CPU 上降低延迟adc：

mov    ecx, eax

bswap  eax
shl    eax, 7             ; top bit in place
shr    ax, 7+7            ; bottom bit in place (without disturbing top bit)

and    ecx, 0x7ffffffe    ; could optimize mov+and with BMI1 andn
and    eax, 0x80000001
or     eax, ecx           ; merge the non-moving bits with the swapped bits

在 Sandybridge 之前的 Intel CPU 上，shr ax 然后读取 EAX 会很糟糕（部分寄存器停顿）。

这看起来像从输入到输出的 5 个周期延迟，与 CPU 上的 adc/adc 版本相同，这是单周期延迟。 （AMD 和自 Broadwell 以来的英特尔）。但是在 Haswell 和更早的版本上，这可能会更好。

我们可以使用 BMI1 andn 和寄存器中的常量保存 mov，或者使用 BMI2 rorx ecx, eax, 16 进行复制和交换，而不是在原地执行 bswap。但是这些位在不太方便的地方。

---

@rkhb 检查位是否不同并翻转它们的想法很好，尤其是使用 PF 检查设置的 0 或 2 位与 1。PF 仅根据结果的低字节设置，所以我们可以' t 只是 and 0x80000001 而不先旋转。

您可以使用 cmov 无分支地执行此操作

; untested, but I think I have the parity correct
rorx    ecx, eax, 31     ; ecx = rotate left by 1.  low 2 bits are the ones we want
xor     edx,edx
test    cl, 3            ; sets PF=1 iff they're the same: even parity
mov     ecx, 0x80000001
cmovpo  edx, ecx         ; edx=0 if bits match, 0x80000001 if they need swapping
xor     eax, edx

使用单微指令 cmov（Broadwell 及更高版本，或 AMD），这是 4 个周期的延迟。 xor-zeroing 和 mov-immediate 不在关键路径上。如果您使用 ECX 以外的寄存器，则可以将 mov-immediate 提升出循环。

---

或者使用setcc，但更糟糕（更多微指令），或者使用2-uop cmov 绑定在CPU 上：

; untested, I might have the parity reversed.
rorx    ecx, eax, 31     ; ecx = rotate left by 1.  low 2 bits are the ones we want
xor     edx,edx
and     ecx, 3           ; sets PF=1 iff they're the same: even parity
setpe   dl
dec     edx              ; 0 or -1
and     edx, 0x80000001
xor     eax, edx

Answer 4

我对这里发布的回复的数量和细节感到非常惊讶。我非常感谢您提供的所有信息，需要一些时间来学习和理解其中的一些信息。 - 与此同时，我自己想出了另一个解决方案。它可能不如您的解决方案有效，但我仍然想发布它并阅读您的想法。

%include "asm_io.inc"
segment .data
outmsg1 db    "Enter integer: ", 0
outmsg2 db    "Before Operation: ", 0
outmsg3 db    "After Operation: ", 0

segment .bss

input1  resd 1
input2  resd 1

segment .text
    global  asm_main
asm_main:
    enter 0,0
    pusha

    mov eax, outmsg1
    call print_string
    call read_int
    xor esi, esi    
    mov esi, eax

    mov eax, outmsg2
    call print_string
    call print_nl
    mov eax, esi
    dump_regs 1

    mov ebx,eax
    mov ecx,eax

    shr ebx, 31
    shl ecx, 31

    shl eax, 1
    shr eax, 2
    shl eax, 1
    or eax,ebx
    or eax,ecx

    mov ebx,eax
    mov eax, outmsg3
    call print_string
    call print_nl
    dump_regs 2


    popa
    mov eax, 0
    leave
    ret

Answer 5

好的，既然已经有不同的答案，我将把我的“评论”变成官方的，并对其进行一些扩展：

    rol    eax,1        ; get the top bit down into low 8 bits
    test   al,3         ; now test the two bits, setting parity flag
    jpe    to_ror       ; if "00" or "11", skip the bit swap
    xor    eax,3        ; flip the two lowest bits (top and bottom original position)
to_ror:
    ror    eax,1        ; restore the positions of bits (top back to b31)

这是单条件跳转变体，即可能不是性能最优的，但应该相当容易理解并且不使用除原始 eax 值和标志寄存器之外的任何其他资源。

另一种选择是避免条件分支，以使用更多指令和寄存器为代价（但在现代 CPU 上的许多情况下应该更快，因为错误预测的分支通常会占用 CPU 资源）（这基本上是OP 附带了，我在原始评论中提到的 “分别提取每个位并重新组合”）：

mov   ebx,eax           ; copy the original value into two new regs
mov   ecx,eax
shr   ebx, 31           ; b31 bit into b0 position (others cleared)
shl   ecx, 31           ; b0 bit into b31 position (others cleared)
and   eax, 0x7FFFFFFE   ; clear b0 and b31 in original value
or    eax,ebx           ; combining the swapped bits back into value
or    eax,ecx