Nach dem ersten Null-Bit suchen (Assembly)?

Question

Ich habe einige Nummern in AH, AL, BL und BH Register. Ich muss prüfen, ob es mindestens ein 0 Bit in jeder der Register in hohen Nibble der Nummer gibt. Wenn ja, dann setze in die Variable überprüfen 10, sonst -10.

Hier ist, was ich versucht:

org 100h 
check dw 0 
mov ah, 11011111b 
mov al, 11011111b 
mov bl, 11011111b 
mov bh, 11011111b 

mov check, 10 
and ax, 0F0F0h 
cmp ax, 0F0F0h 
je no_all_zeros 
and bx, 0F0F0h 
cmp bx, 0F0F0h 
jne has_zeros 
no_all_zeros: 
mov check, -10 
has_zeros: 

ret 

Answer 1

The righ t Art und Weise, dies zu tun wäre:

.MODEL SMALL 
.STACK 100h 

.DATA 
check DB 10 
.CODE 
mov ax, @DATA 
mov ds, ax 
xor ax, ax 
xor bx, bx 
xor cx, cx 

; Assign values 
mov cl, 4 ; Assign rotator - 4 bits 
mov ax, 1011101010111010b 
mov bx, 1110100010110100b 

; Check AX 
xor ax, 0F0F0h ; masking 
shr ah, cl ; rotating and expecting other than 0 
cmp ah, 0 ; ah = 0 ? 
je noZero 
shr al, cl 
cmp al, 0 
je noZero 
xor bx, 0F0F0h 
shr bh, cl 
cmp bh, 0 
je noZero 
shr bl, cl 
cmp bl, 0 
je noZero 
jmp exit 
noZero: 
mov check, -10 
exit: 
mov ah, 4ch 
int 21h 

Answer 2

Wenn Sie gerade benötigen, um zu sehen, ob es eine 0-Bit in AH ist, dann vergleichen gegen 0xFF. Wenn der Vergleich nicht gleich ist, dann gibt es mindestens ein 0-Bit. Das Gleiche gilt für die anderen Register.

Wenn Sie wirklich das erste 0 Bit finden möchten, können Sie es mit mehreren Schichten machen. Oder Sie können die BSF-Anweisung verwenden (vorausgesetzt, die Assembly 80386), obwohl Sie den Operanden negieren müssen und nach dem ersten gesetzten Bit suchen müssen.

Schließlich gibt es eine Alternative zur Verwendung der Mehrfachschichten, wenn Sie BSF nicht verwenden können. Ich denke, die Bit Twiddling Hacks hat ein Beispiel. Es wird in C sein, aber die Konvertierung in Assembly sollte nicht zu hart sein.

bearbeiten, nach Ihrer Info:

Sie wollen also sehen, ob das obere Nibble jedes Registers mindestens ein 0-Bit enthält? Und Sie möchten nicht die Register ändern, die die Werte enthalten.

mov cx, ax 
and cx, 0xF0F0 ; this clears the low nibbles so you don't have to worry about them 
xor cx, 0xF0F0 ; CX will be non-zero if there were bits set in the high nibbles 
jz NoZeros 
; Here you'll need to check CH and CL individually to see if they're both non-zero 

Answer 3

mov check, 10 
    and ax, bx 
    and ax, F0F0h 
    cmp ax, F0F0h 
    jne has_zeros 
    mov check, -10 
has_zeros: 

EDIT endlich verstehe ich, was Sie wollen: das Ergebnis sollte -10 sein, wenn mindestens ein 0xF in seinem hohen knabbern hat:

mov check, -10 
    xor ax, F0F0h 
    test ax, F000h 
    je no_zero 
    test ax, 00F0h 
    je no_zero 
    xor bx, F0F0h 
    test bx, F000h 
    je no_zero 
    test bx, 00F0h 
    je no_zero 
    mov check, 10 
no_zero: 

Answer 4

cmp AH, FFh 
jl has_zeros 

Sieht aus als würde es für mich funktionieren, aber ich nehme an, mit der linken Hälfte meinen Sie die oberen 8 Bits. Könnte aber falsch liegen.

Answer 5

sollte 10 nur geben, wenn in allen Zahlen in den Registern mindestens ein Null-Bit in der linken Hälfte ist

Diese Arbeit sollte:

mov [check], -10 

    add al,0x10 
    mov al,0 
    adc ax,0x1000 
    adc al,0 
    add bl,0x10 
    adc al,0 
    add bh,0x10 
    adc al,0 
         ;al = number of high nibbles that had all bits set 

    test al,al  ;Did any high nibble have all bits set? 
    jne .l1   ; yes, check = -10 
    mov [check], 10 ; no, check = 10 
.l1: 

Edit: Wenn Sie will nicht die Werte in den Registern ersetzen, dann ax und bx auf den Stapel drücken und sie danach wieder öffnen.