Logical and Bitwise Instructions

Analogy categoryAnalogies

AND, OR, XOR, and NOT operate on their operands bit-by-bit, with no carrying between bit positions -- each output bit depends only on the corresponding input bit(s). AND sets a result bit only when both source bits are 1, useful for masking off unwanted bits. OR sets a result bit when either source bit is 1, useful for setting flags. XOR sets a result bit when the source bits differ, useful for toggling. NOT flips every bit of a single operand to its complement.

🏏

Cricket analogy: Checking whether a bowler has taken a wicket AND kept the economy rate under 6 combines two conditions into one true/false outcome, just as AND eax, ebx combines two bit patterns, keeping a bit only where both operands have it set.

Shifts and Rotates

Shift and rotate instructions manipulate bit positions within a register. SHL and SHR are logical shifts that fill vacated bits with 0, making them a fast way to multiply or divide unsigned values by powers of two. SAR is an arithmetic shift right that instead replicates the original sign bit into the vacated high-order bits, correctly preserving the sign of a negative number during a signed division by two. ROL and ROR rotate bits circularly around the register instead of discarding them, so no information is lost.

🏏

Cricket analogy: Doubling a batsman's strike rate by shifting the decimal mirrors SHL eax, 1, which shifts every bit left by one position, effectively multiplying an unsigned value by two.

nasm

; Extract the low nibble and check a specific flag bit
section .data
    status dd 0b10110100

section .text
global _start
_start:
    mov eax, [status]
    and eax, 0x0F              ; isolate low nibble -> eax = 0b0100
    mov ebx, [status]
    shr ebx, 4                 ; shift right 4 to get high nibble
    test dword [status], 0x10  ; check bit 4 without modifying status
    jnz bit_set
    jmp done
bit_set:
    xor ecx, ecx                ; ecx = 0, idiomatic register clear
done:
    mov eax, 1
    int 0x80

Masking Bits with AND and TEST

Bit masking with AND, OR, and TEST is the standard technique for reading, setting, and clearing individual bits within a packed field, such as a status register holding several independent flags. AND with a mask that has zeros in the unwanted positions clears those bits while leaving others untouched. TEST performs the same bitwise AND internally to set the flags but discards the result, leaving both operands unmodified -- making it the preferred way to check a bit's state without accidentally destroying data you still need.

🏏

Cricket analogy: Checking only whether the third umpire's decision flag is set, ignoring all other review flags, mirrors AND eax, 0x04 masking out every bit except the one of interest.

TEST eax, mask performs the same bitwise AND as AND eax, mask internally to compute flags like ZF, but discards the result and leaves eax unmodified -- the idiomatic, non-destructive way to check whether specific bits are set before a conditional jump.

XOR Idioms and Bit Toggling

XOR has several idiomatic uses beyond bit toggling. XOR reg, reg is the standard, compact way to zero a register -- shorter in encoding than MOV reg, 0 and just as fast, because XORing any value with itself always produces zero. Historically, XOR was also used to swap two registers without a temporary third register via three successive XOR instructions, though modern code typically prefers XCHG for clarity. XOR is also the basis of simple checksum and parity computations because XORing a value with the same mask twice restores the original.

🏏

Cricket analogy: Resetting a bowler's over count to zero at the start of a new spell, regardless of its previous value, mirrors the common idiom XOR eax, eax, which zeroes a register faster and with a smaller encoding than MOV eax, 0.

AND, OR, and XOR always clear the Overflow and Carry flags and set flags based purely on the bit-pattern result, which means code that relies on CF or OF being meaningful after a logical instruction (rather than an arithmetic one) will read stale or misleading information -- always re-check with CMP or an arithmetic instruction if carry/overflow semantics matter next.

AND, OR, XOR, and NOT operate bit-by-bit and never carry between bit positions, unlike arithmetic instructions.
SHL/SHR are logical shifts that fill vacated bits with 0; SAR is an arithmetic shift that preserves the sign bit.
ROL/ROR rotate bits around the register instead of discarding them, useful for cyclic bit manipulation.
TEST performs a non-destructive AND purely to set flags, leaving both operands unchanged.
AND with a mask clears unwanted bits; OR with a mask sets specific bits; XOR toggles specific bits.
XOR reg, reg is the idiomatic, compact way to zero a register on x86.
Logical instructions always clear CF and OF, so signed/unsigned overflow checks must use arithmetic instructions instead.

Practice what you learned

1. What distinguishes SAR from SHR when shifting a negative number right?

2. Why would you use TEST eax, 0x01 instead of AND eax, 0x01 to check the low bit?

3. What is the idiomatic purpose of XOR eax, eax?

4. Which instruction rotates bits off one end of a register back into the other end, rather than discarding them?

5. After executing AND eax, ebx, what happens to the Carry and Overflow flags?

Was this page helpful?

Arithmetic Instructions

Data Types and Directives

Related Study Notes in Programming

Browse all study notes

Programming

Apache Spark Study Notes

Programming · 30 topics

Programming

Apache Flink Study Notes

Programming · 30 topics

Programming

Hadoop Study Notes

Programming · 30 topics

Programming

Snowflake Study Notes

Programming · 30 topics

Programming

Apache Airflow Study Notes

Programming · 30 topics

Programming

dbt (Data Build Tool) Study Notes

Programming · 30 topics

Topics covered

#Programming#AssemblyLanguageStudyNotes#LogicalAndBitwiseInstructions#Logical#Bitwise#Instructions#Shifts#StudyNotes#SkillVeris#ExamPrep

Logical and Bitwise Instructions