How to Compare Two Numbers in Assembly Language

Comparing two numbers is a fundamental operation in any programming language, and assembly language is no exception. This article delves into the techniques used to compare numbers in assembly language, illustrating the process with a practical example of sorting an array of bytes using a bubble sort algorithm.

Comparing and Sorting with Bubble Sort

Assembly language provides several instructions for comparing numbers. The most common are CMP (compare), JE (jump if equal), JNE (jump if not equal), JG (jump if greater), JGE (jump if greater or equal), JL (jump if less), and JLE (jump if less or equal). These instructions allow for branching based on the comparison results.

To illustrate the comparison process, let’s examine a bubble sort implementation for a small array of bytes. We’ll use a simplified version optimized for a fixed-size array to focus on the core comparison logic.

; Assume MyArray is defined as a byte array: MyArray db 12h, 34h, 56h, 78h, 90h, 0ABh, 0CDh

push ebx     ; Preserve EBX register

; Load byte values into registers, using word-sized accesses where possible.
mov ax, word ptr MyArray[0] 
mov cx, word ptr MyArray[2]
mov dx, word ptr MyArray[4]
mov bl, MyArray[6]

; Bubble sort implementation - simplified for a 7-element array.

; First Pass (Bottom to Top)
.if al > ah
    xchg al, ah
.endif
.if ah > cl
    xchg ah, cl
.endif
; ... (Similar comparisons for other register pairs)
.if dh > bl
    xchg dh, bl
.endif


; Second Pass (Top to Bottom)
.if dh < dl
    xchg dh, dl
.endif
; ... (Similar comparisons for other register pairs)
.if ah < al
    xchg ah, al
.endif

; ... (Remaining passes with reduced comparisons per pass)

; ... (Fifth and Sixth Pass)


; Store sorted values back into the array
mov word ptr MyArray[0], ax
mov word ptr MyArray[2], cx
mov word ptr MyArray[4], dx
mov MyArray[6], bl

pop ebx      ; Restore EBX register

This code snippet demonstrates the core of a bubble sort in assembly. Each .if block uses the CMP instruction implicitly to compare two registers and then conditionally swaps them using XCHG if they are out of order. Multiple passes ensure the data is fully sorted.

Optimized Comparison Techniques

For larger arrays, loop structures would be employed to iterate through the data. This simplified example showcases the fundamental comparison logic. More advanced techniques, such as using jump tables or more efficient sorting algorithms, can be implemented for improved performance. However, this example highlights the fundamental building blocks of numerical comparison in assembly.

The code first loads byte values from memory into registers, leveraging word-sized moves where possible for efficiency. It then performs pairwise comparisons and swaps using conditional instructions. Finally, it stores the sorted bytes back into memory. Note that this code utilizes word ptr to load two bytes at once from the byte array, effectively working with pairs of values. This optimization reduces the number of memory accesses required.

This example demonstrates how assembly language allows direct manipulation of registers for fine-grained control over comparisons. It also highlights the importance of understanding how data is represented in memory and registers for efficient operations. By understanding these principles, developers can write highly optimized code for specific tasks.