COA Notes
HubARM ArchitectureCISC ArchitectureCloud Computing HardwareEmbedded Processor ArchitectureModern CPU DesignRISC Architecturex86 ArchitectureALU DesignBinary AdditionBinary SubtractionCarry Lookahead AdderDivision AlgorithmsFloating Point ArithmeticMultiplication AlgorithmsAddressing TechniquesAssembly InstructionsAssembly Language IntroductionAssembly Program ExamplesLoops in AssemblyProcedure CallsARM Processor Case StudyIntel 8086 ArchitectureModern Intel CPURaspberry Pi ArchitectureSmartphone Processor ArchitectureBasic Computer StructureBus SystemFetch-Decode-Execute CycleInstruction CyclePerformance MetricsSystem ComponentsControl UnitCPU ArchitectureGeneral Purpose RegistersHardwired Control UnitMicroprogrammed Control UnitProcessor RegistersStack OrganizationBinary Arithmetic — Computer Organization & ArchitectureCharacter Encoding — Computer Organization & ArchitectureError Detection CodesFloating Point RepresentationIEEE 754 StandardNumber Systems ReviewSigned Number RepresentationDirect Memory Access (DMA)Interrupt-Driven I/OI/O InterfaceI/O ProcessorsPeripheral DevicesProgrammed I/OUSB and Modern InterfacesAddressing ModesInstruction ExecutionInstruction FormatInstruction TypesMachine Language BasicsRISC vs CISCCache Memory QuestionsCOA CheatsheetComputer Organization Interview QuestionsGATE COA QuestionsPipelining QuestionsComputer Organization vs ArchitectureEvolution of ComputersFunctional Units of ComputerVon Neumann ArchitectureWhat is Computer Organization?Associative MemoryCache Mapping TechniquesCache Memory — Computer Organization & ArchitectureMain MemoryMemory Hierarchy — Computer Organization & ArchitectureMemory PerformanceRAM and ROMVirtual Memory — Computer Organization & ArchitectureDistributed ProcessingGPU ArchitectureMulticore ProcessorsParallel Processing BasicsShared Memory SystemsSuperscalar ArchitectureVector ProcessingControl HazardsData HazardsForwarding TechniquesInstruction PipelinePipeline HazardsPipeline IntroductionPipeline PerformanceALU Design ProjectAssembly Language LabsCache SimulationComputer Architecture ProjectsPipeline SimulationArithmetic Logic Unit (ALU)Arithmetic Micro-operationsLogic Micro-operationsRegister Transfer LanguageRegister Transfer OperationsShift Micro-operationsGlossary of Terms — Computer Organization & ArchitectureImportant Formulas — Computer Organization & ArchitectureQuick Revision Notes — Computer Organization & ArchitectureRecommended Books — Computer Organization & Architecture
Practical assembly language programs demonstrating common algorithms and programming patterns.
Introduction
The best way to learn assembly is through complete, working programs. This page presents progressively complex examples that demonstrate how common programming tasks translate to assembly instructions. Each example includes the algorithm logic, the complete code, and a trace showing how registers change during execution. These are not just code snippets — they are complete programs you can run in MARS or any MIPS simulator.
Example 1: Swap Two Numbers
The simplest demonstration of register operations:
assembly example
.data
x: .word 25
y: .word 42
msg1: .asciiz "Before swap: x="
msg2: .asciiz ", y="
msg3: .asciiz "\nAfter swap: x="
newline: .asciiz "\n"
.text
.globl main
main:
# Load values
lw $t0, x # $t0 = 25
lw $t1, y # $t1 = 42
# Swap using XOR (no temporary needed!)
xor $t0, $t0, $t1 # $t0 = 25 XOR 42
xor $t1, $t0, $t1 # $t1 = (25 XOR 42) XOR 42 = 25
xor $t0, $t0, $t1 # $t0 = (25 XOR 42) XOR 25 = 42
# Store back
sw $t0, x # x = 42
sw $t1, y # y = 25
# Print result
la $a0, msg3
li $v0, 4
syscall
move $a0, $t0
li $v0, 1
syscall
la $a0, msg2
li $v0, 4
syscall
move $a0, $t1
li $v0, 1
syscall
li $v0, 10
syscallArchitecture insight: XOR swap uses no memory, no temporary register — pure ALU operations.
Example 2: Fibonacci Sequence
Generate first N Fibonacci numbers:
Example
.data
fib: .space 40 # Space for 10 integers (10 × 4 bytes)
n: .word 10
space: .asciiz " "
.text
.globl main
main:
la $t0, fib # Base address of array
lw $t1, n # N = 10
# Initialize first two: fib[0]=0, fib[1]=1
li $t2, 0
sw $t2, 0($t0) # fib[0] = 0
li $t2, 1
sw $t2, 4($t0) # fib[1] = 1
# Generate remaining
li $t3, 2 # i = 2
fib_loop:
bge $t3, $t1, print_all # if i >= n, done generating
# fib[i] = fib[i-1] + fib[i-2]
sll $t4, $t3, 2 # offset = i * 4
add $t5, $t0, $t4 # address of fib[i]
lw $t6, -4($t5) # fib[i-1]
lw $t7, -8($t5) # fib[i-2]
add $t6, $t6, $t7 # fib[i-1] + fib[i-2]
sw $t6, 0($t5) # store fib[i]
addi $t3, $t3, 1 # i++
j fib_loop
print_all:
li $t3, 0 # i = 0
print_loop:
bge $t3, $t1, done
sll $t4, $t3, 2
add $t4, $t0, $t4
lw $a0, 0($t4)
li $v0, 1 # Print integer
syscall
la $a0, space
li $v0, 4 # Print space
syscall
addi $t3, $t3, 1
j print_loop
done:
li $v0, 10
syscall
Output: 0 1 1 2 3 5 8 13 21 34
Example 3: Bubble Sort
Example
.data
arr: .word 64, 34, 25, 12, 22, 11, 90, 45
n: .word 8
space: .asciiz " "
msg: .asciiz "Sorted: "
.text
.globl main
main:
la $s0, arr # Array base
lw $s1, n # Array size
# Outer loop: for i = 0 to n-2
li $t0, 0 # i = 0
outer:
addi $t1, $s1, -1 # n-1
bge $t0, $t1, print_sorted
# Inner loop: for j = 0 to n-i-2
li $t2, 0 # j = 0
sub $t3, $t1, $t0 # n-1-i (inner limit)
inner:
bge $t2, $t3, next_outer
# Compare arr[j] and arr[j+1]
sll $t4, $t2, 2 # j * 4
add $t4, $s0, $t4 # &arr[j]
lw $t5, 0($t4) # arr[j]
lw $t6, 4($t4) # arr[j+1]
ble $t5, $t6, no_swap # if arr[j] <= arr[j+1], skip
# Swap arr[j] and arr[j+1]
sw $t6, 0($t4) # arr[j] = arr[j+1]
sw $t5, 4($t4) # arr[j+1] = arr[j]
no_swap:
addi $t2, $t2, 1 # j++
j inner
next_outer:
addi $t0, $t0, 1 # i++
j outer
print_sorted:
la $a0, msg
li $v0, 4
syscall
li $t0, 0
print_loop:
bge $t0, $s1, exit
sll $t1, $t0, 2
add $t1, $s0, $t1
lw $a0, 0($t1)
li $v0, 1
syscall
la $a0, space
li $v0, 4
syscall
addi $t0, $t0, 1
j print_loop
exit:
li $v0, 10
syscall
Architecture insight: Notice the nested loops generate many branches — this is where branch prediction matters. Also, the array accesses show indexed addressing in action.
Example 4: String Length (Pointer Traversal)
Example
.data
str: .asciiz "Computer Organization"
msg: .asciiz "Length: "
.text
.globl main
main:
la $t0, str # Pointer to start of string
li $t1, 0 # Length counter
strlen_loop:
lb $t2, 0($t0) # Load byte at pointer
beq $t2, $zero, done # If null terminator, done
addi $t1, $t1, 1 # length++
addi $t0, $t0, 1 # pointer++ (next character)
j strlen_loop
done:
la $a0, msg
li $v0, 4
syscall
move $a0, $t1
li $v0, 1
syscall # Prints: Length: 21
li $v0, 10
syscall
Architecture insight: This demonstrates register indirect addressing with auto-increment — the pointer walks through memory byte by byte.
Example 5: Power Function (Recursive)
Calculate base^exponent using recursion:
assembly example
.text
.globl main
main:
li $a0, 2 # base = 2
li $a1, 10 # exponent = 10
jal power # Call power(2, 10)
move $a0, $v0 # Print result
li $v0, 1
syscall # Should print 1024
li $v0, 10
syscall
# power(base, exp): returns base^exp
power:
addi $sp, $sp, -12
sw $ra, 8($sp)
sw $a0, 4($sp) # Save base
sw $a1, 0($sp) # Save exponent
# Base case: exp == 0 → return 1
beq $a1, $zero, power_base
# Recursive: return base * power(base, exp-1)
addi $a1, $a1, -1 # exp - 1
jal power # Recursive call
lw $a0, 4($sp) # Restore base
mul $v0, $a0, $v0 # base * power(base, exp-1)
j power_return
power_base:
li $v0, 1 # Return 1
power_return:
lw $ra, 8($sp)
addi $sp, $sp, 12
jr $raExample 6: Binary Search
Example
.data
sorted_arr: .word 2, 5, 8, 12, 16, 23, 38, 45, 56, 72
arr_size: .word 10
target: .word 23
found_msg: .asciiz "Found at index: "
not_found_msg: .asciiz "Not found"
.text
.globl main
main:
la $a0, sorted_arr # Array base
li $a1, 0 # low = 0
lw $a2, arr_size
addi $a2, $a2, -1 # high = size - 1
lw $a3, target # target value
jal binary_search
bltz $v0, not_found # If result < 0, not found
la $a0, found_msg
li $v0, 4
syscall
move $a0, $v0
li $v0, 1
syscall
j exit
not_found:
la $a0, not_found_msg
li $v0, 4
syscall
exit:
li $v0, 10
syscall
# binary_search(arr, low, high, target) → index or -1
binary_search:
bgt $a1, $a2, bs_not_found # if low > high, not found
# mid = (low + high) / 2
add $t0, $a1, $a2
srl $t0, $t0, 1 # mid = (low+high) >> 1
# Load arr[mid]
sll $t1, $t0, 2 # mid * 4
add $t1, $a0, $t1 # &arr[mid]
lw $t2, 0($t1) # arr[mid]
beq $t2, $a3, bs_found # if arr[mid] == target
bgt $t2, $a3, bs_left # if arr[mid] > target, search left
# Search right half
addi $a1, $t0, 1 # low = mid + 1
j binary_search
bs_left:
addi $a2, $t0, -1 # high = mid - 1
j binary_search
bs_found:
move $v0, $t0 # Return mid index
jr $ra
bs_not_found:
li $v0, -1 # Return -1
jr $ra
Key Takeaways
- Complete assembly programs require data declarations (.data), code (.text), system calls for I/O, and proper program termination
- Array operations in assembly are explicit pointer arithmetic: base_address + index × element_size
- Loops use branch instructions for both the condition check and the back-jump
- Recursive functions require careful stack management — saving and restoring $ra and arguments on each call
- String operations work byte-by-byte using load byte (lb) and pointer increment
- These patterns (loops, conditionals, function calls, array access) are the building blocks of ALL programs — understanding them in assembly reveals exactly what the CPU does
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Assembly Program Examples.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Computer Organization & Architecture topic.
Search Terms
computer-organization, computer organization & architecture, computer, organization, assembly, language, program, examples
Related Computer Organization & Architecture Topics
Continue learning this concept
Assembly LanguageAddressing TechniquesAssembly language addressing techniques and modes for accessing data in memory.Assembly LanguageAssembly InstructionsComplete guide to assembly language instructions including data transfer, arithmetic, logic, and control flow.Assembly LanguageAssembly Language IntroductionIntroduction to assembly language programming, its relationship to machine code, and why it matters.Assembly LanguageLoops in AssemblyImplementing loop constructs in assembly language: for, while, do-while, and nested loops.Assembly LanguageProcedure CallsAssembly language procedure calls, stack frames, calling conventions, and parameter passing.Practicals And SimulationsAssembly Language LabsHands-on assembly language programming labs with exercises and solutions.