Assembly Language Simple Calculator
Comprehensive Guide to Writing a Simple Calculator in Assembly Language
Assembly language provides the most direct way to interact with a computer’s hardware, making it ideal for performance-critical applications and understanding how processors execute instructions. This guide will walk you through creating a simple calculator in assembly language, covering fundamental concepts, practical implementations, and optimization techniques.
1. Understanding Assembly Language Basics
Before diving into calculator implementation, it’s essential to grasp these core concepts:
- Registers: Temporary storage locations within the CPU (e.g., AX, BX, CX in x86)
- Instructions: Basic commands like MOV, ADD, SUB that the CPU executes
- Memory Addressing: How to access data stored in RAM
- Flags Register: Contains status bits (ZF, CF, OF) that indicate operation results
- Stack Operations: PUSH/POP instructions for function calls and local variables
2. Calculator Design Considerations
When designing an assembly calculator, consider these architectural decisions:
| Design Aspect | x86 Approach | ARM Approach |
|---|---|---|
| Register Usage | AX, BX, CX, DX for operands | R0-R3 for parameters, R4-R11 for locals |
| Instruction Set | ADD, SUB, MUL, DIV | ADD, SUB, MUL, SDIV/UDIV |
| Division Handling | DIV instruction (AX/DX pair) | Separate signed/unsigned instructions |
| Flag Management | Automatic (EFLAGS register) | Conditional execution suffixes |
3. Step-by-Step Implementation
3.1 x86 Assembly Calculator (16-bit)
; Simple 16-bit calculator for x86
; Input: AL = operation code, BX = operand1, CX = operand2
; Output: AX = result, sets flags
section .text
global _start
_start:
; Example: Calculate 15 + 7
mov bx, 15 ; First operand
mov cx, 7 ; Second operand
mov al, 1 ; 1 = addition
call calculator
; Result is in AX
mov ax, 4c00h ; Exit program
int 21h
calculator:
cmp al, 1 ; Addition
je do_add
cmp al, 2 ; Subtraction
je do_sub
cmp al, 3 ; Multiplication
je do_mul
cmp al, 4 ; Division
je do_div
ret
do_add:
mov ax, bx
add ax, cx
ret
do_sub:
mov ax, bx
sub ax, cx
ret
do_mul:
mov ax, bx
imul cx ; Signed multiply
ret
do_div:
mov ax, bx
cwd ; Sign extend AX into DX
idiv cx ; Signed divide
ret
3.2 ARM Assembly Calculator (32-bit)
@ ARM assembly calculator example
@ Input: R0 = operation, R1 = operand1, R2 = operand2
@ Output: R0 = result
.global calculator
calculator:
PUSH {LR} @ Save return address
CMP R0, #1 @ Addition
BEQ add_op
CMP R0, #2 @ Subtraction
BEQ sub_op
CMP R0, #3 @ Multiplication
BEQ mul_op
CMP R0, #4 @ Division
BEQ div_op
B end_calc
add_op:
ADD R0, R1, R2
B end_calc
sub_op:
SUB R0, R1, R2
B end_calc
mul_op:
MUL R0, R1, R2
B end_calc
div_op:
SDIV R0, R1, R2 @ Signed division
end_calc:
POP {PC} @ Return
4. Handling Special Cases
Robust calculators must handle these edge cases:
- Division by Zero: Always check divisor before division operation
; x86 division by zero check cmp cx, 0 jne divide_ok ; Handle error (set carry flag or jump to error handler) divide_ok: idiv cx
- Overflow Conditions: Use JO (Jump if Overflow) after arithmetic operations
add ax, bx jo overflow_handler ; Jump if overflow occurred
- Signed vs Unsigned: Use appropriate instructions (IMUL vs MUL, IDIV vs DIV)
; Signed multiplication imul cx ; Unsigned multiplication mul cx
5. Performance Optimization Techniques
| Technique | x86 Example | Performance Gain |
|---|---|---|
| Loop Unrolling | Replace loops with repeated instructions | 15-30% faster |
| Register Allocation | Minimize memory accesses | 20-50% faster |
| Instruction Pairing | Pair compatible instructions | 5-15% faster |
| Strength Reduction | Replace MUL with shifts/adds | 30-70% faster |
6. Debugging Assembly Calculators
Effective debugging strategies:
- Single-Stepping: Use debuggers like GDB or Visual Studio to execute instructions one at a time
- Register Inspection: Examine register values after each operation
- Flag Checking: Verify status flags (ZF, CF, OF) after arithmetic operations
- Memory Dumps: Inspect memory locations used for storage
- Breakpoints: Set breakpoints at critical sections of code
Example GDB commands for debugging:
# Assemble with debugging symbols
nasm -f elf32 -g calculator.asm
# Load in GDB
gdb ./calculator
# Common commands
break _start # Set breakpoint
run # Start execution
stepi # Step one instruction
info registers # Show registers
x/x $eax # Examine memory
7. Advanced Topics
7.1 Floating Point Calculations
The x87 FPU provides specialized instructions for floating-point arithmetic:
; x87 FPU addition example
fld qword [operand1] ; Load first operand
fadd qword [operand2] ; Add second operand
fstp qword [result] ; Store result
7.2 SIMD Instructions
Modern CPUs support SIMD (Single Instruction Multiple Data) for parallel operations:
; SSE example: Add four floats in parallel
movaps xmm0, [array1] ; Load 4 floats
addps xmm0, [array2] ; Add 4 floats
movaps [result], xmm0 ; Store 4 results