Assembly Language
Complete Notes

What is Assembly Language?

Assembly language is a low-level programming language that uses mnemonic codes (like MOV, ADD, SUB) instead of binary machine code. It provides direct control over hardware and is specific to a processor architecture.

Why Learn Assembly?

• Understand how computers work at the hardware level
• Write highly optimized code for performance-critical applications
• Essential for system programming, device drivers, and embedded systems
• Reverse engineering and malware analysis
• Foundation for understanding operating systems

Programming Language Levels

Assembler vs Compiler

Common Assemblers

• MASM — Microsoft Macro Assembler (Windows)
• NASM — Netwide Assembler (Cross-platform)
• TASM — Turbo Assembler (DOS/Windows)
• GAS — GNU Assembler (Linux)

What is a Register?

A register is a small, fast storage location inside the CPU used to hold data temporarily during processing.

Types of Registers (8086/8088)

Segment Registers

Special Registers

FLAGS Register

Contains single-bit flags that indicate the status of the CPU and the result of operations.

• ZF (Zero Flag) — Set if result is zero
• CF (Carry Flag) — Set if carry/borrow occurs
• SF (Sign Flag) — Set if result is negative
• OF (Overflow Flag) — Set if signed overflow occurs
• PF (Parity Flag) — Set if result has even parity

What is an Addressing Mode?

An addressing mode specifies how the operand of an instruction is accessed.

Types of Addressing Modes

Examples

; Immediate Addressing
MOV AX, 10          ; AX = 10

; Register Addressing
MOV AX, BX          ; AX = value in BX

; Direct Addressing
MOV AX, [2000h]    ; AX = value at memory location 2000h

; Register Indirect
MOV AX, [BX]       ; AX = value at address stored in BX

MOV Instruction

The MOV instruction copies data from source to destination.

; Syntax: MOV destination, source

MOV AX, 10         ; AX = 10
MOV BX, AX         ; BX = AX
MOV [1000h], AX   ; Memory[1000h] = AX

XCHG Instruction

Exchanges (swaps) values between two operands.

MOV AX, 5
MOV BX, 10
XCHG AX, BX        ; AX = 10, BX = 5

LEA, LDS, LES Instructions

PUSH and POP

; PUSH: Store value on stack
MOV AX, 10
PUSH AX            ; Stack now contains 10

; POP: Retrieve value from stack
POP BX             ; BX = 10

ADD and SUB

; ADD: Addition
MOV AX, 5
MOV BX, 3
ADD AX, BX         ; AX = 8

; SUB: Subtraction
SUB AX, BX         ; AX = 5

INC and DEC

MOV AX, 10
INC AX             ; AX = 11 (increment by 1)
DEC AX             ; AX = 10 (decrement by 1)

MUL and DIV

; Multiplication
MOV AX, 5
MOV BX, 3
MUL BX             ; AX = 15

; Division
MOV AX, 10
MOV BX, 3
DIV BX             ; AX = 3, DX = 1 (remainder)

NEG Instruction

Negates a number (two's complement).

MOV AX, 5
NEG AX             ; AX = -5

Logical Instructions

; AND Example
MOV AL, 11110000b
AND AL, 00001111b   ; AL = 00000000b

; OR Example
MOV AL, 11110000b
OR AL, 00001111b    ; AL = 11111111b

; XOR trick to clear register
XOR AX, AX          ; AX = 0 (faster than MOV AX, 0)

Shift Instructions

MOV AL, 00001100b   ; AL = 12
SHL AL, 1           ; AL = 00011000b = 24
SHR AL, 1           ; AL = 00001100b = 12

Rotate Instructions

Unconditional Jump

JMP label          ; Jump to label

label:
    MOV AX, 5

Conditional Jumps

CMP Instruction

Compares two values by subtracting them (without storing result) and sets flags.

MOV AX, 10
MOV BX, 5
CMP AX, BX         ; Compare AX and BX
JG greater         ; Jump if AX > BX

greater:
    MOV CX, 1

LOOP Instruction

MOV CX, 5          ; Counter
loop_start:
    ; Your code here
    LOOP loop_start   ; Decrement CX, jump if CX != 0

Example: Print 1 to 5

MOV CX, 5
MOV AX, 1

print_loop:
    ; Print AX value (pseudo-code)
    INC AX
    LOOP print_loop

What is a Stack?

The stack is a LIFO (Last In, First Out) data structure used for temporary storage. SP (Stack Pointer) points to the top of the stack.

PUSH and POP

MOV AX, 10
MOV BX, 20

PUSH AX            ; Stack: [10]
PUSH BX            ; Stack: [20, 10]

POP CX             ; CX = 20, Stack: [10]
POP DX             ; DX = 10, Stack: []

Why Use the Stack?

• Save register values before using them
• Pass parameters to procedures
• Store return addresses for function calls
• Allocate local variables

PUSHF and POPF

Save and restore the FLAGS register.

PUSHF              ; Save FLAGS register
; ... some operations ...
POPF               ; Restore FLAGS register

What is a Procedure?

A procedure (or subroutine) is a reusable block of code that can be called multiple times.

Defining a Procedure

myProc PROC
    ; Procedure code here
    RET              ; Return to caller
myProc ENDP

CALL and RET

; Main program
MOV AX, 5
CALL addTen        ; Call procedure
; AX now contains 15

addTen PROC
    ADD AX, 10
    RET
addTen ENDP

Passing Parameters

Parameters can be passed via registers or the stack.

; Via Registers
MOV AX, 10
MOV BX, 20
CALL addNumbers    ; Result in AX

addNumbers PROC
    ADD AX, BX
    RET
addNumbers ENDP

Preserving Registers

myProc PROC
    PUSH AX          ; Save register
    PUSH BX
    
    ; Procedure code
    
    POP BX           ; Restore registers
    POP AX
    RET
myProc ENDP

String Instructions

REP Prefix

Repeats a string instruction CX times.

MOV CX, 10         ; Repeat 10 times
REP MOVSB          ; Move 10 bytes

Example: Copy String

; Source string
source DB 'Hello$'
dest   DB 6 DUP(0)

; Copy string
LEA SI, source
LEA DI, dest
MOV CX, 6
REP MOVSB

Direction Flag

What is an Interrupt?

An interrupt is a signal that temporarily stops the CPU to execute a special routine (ISR — Interrupt Service Routine).

INT Instruction

INT number         ; Call interrupt

Common BIOS Interrupts

Example: Print Character (INT 10h)

MOV AH, 0Eh        ; Function: Teletype output
MOV AL, 'A'       ; Character to print
INT 10h            ; Call BIOS video service

Example: Print String (INT 21h)

msg DB 'Hello, World!$'

LEA DX, msg
MOV AH, 09h        ; Function: Display string
INT 21h            ; Call DOS service

Example: Read Keyboard (INT 16h)

MOV AH, 00h        ; Function: Read key
INT 16h            ; Wait for key press
; AL now contains ASCII code

Program Termination

MOV AH, 4Ch        ; Function: Terminate program
INT 21h

What is a Macro?

A macro is a code template that gets expanded at assembly time. It's like a function but is replaced inline.

Defining a Macro

macroName MACRO parameter1, parameter2
    ; Macro body
ENDM

Example: Simple Macro

addTen MACRO reg
    ADD reg, 10
ENDM

; Usage
MOV AX, 5
addTen AX          ; Expands to: ADD AX, 10

Macro vs Procedure

Example: Print Character Macro

printChar MACRO char
    MOV AH, 02h
    MOV DL, char
    INT 21h
ENDM

; Usage
printChar 'A'
printChar 'B'

Project Requirements

Build a simple Calculator that performs addition, subtraction, multiplication, and division.

Features to Implement

• Display a menu with options: 1. Add, 2. Subtract, 3. Multiply, 4. Divide, 5. Exit
• Take two numbers as input from the user
• Perform the selected operation
• Display the result
• Loop back to menu until user selects Exit

Sample Structure

.model small
.stack 100h
.data
    menu DB '1. Add$'
    ; ... more menu items
    
.code
main PROC
    MOV AX, @data
    MOV DS, AX
    
menu_loop:
    ; Display menu
    CALL displayMenu
    
    ; Get user choice
    CALL getChoice
    
    ; Process choice
    CMP AL, '1'
    JE addition
    ; ... handle other cases
    
    JMP menu_loop
    
addition:
    CALL addNumbers
    JMP menu_loop
    
main ENDP
END main

Bonus Features

• Handle division by zero error
• Support multi-digit numbers
• Add modulus operation
• Display result in decimal format
• Use macros for repetitive tasks