nasm-know-hows

nasm assembly related stuff

View on GitHub

🎓 NASM Assembly Programming - Complete Tutorial

Welcome to your comprehensive NASM assembly programming course! This tutorial will take you from beginner to advanced assembly programmer through structured, hands-on lessons.

📚 Course Structure

This course is organized into progressive levels with 20 core topics plus advanced projects.

📁 Directory Structure

nasm-tutorial/
├── README.md                    # This file - course overview
├── topics/                      # Individual topic lessons
│   ├── topic-01-setup.md
│   ├── topic-02-registers.md
│   └── ...
└── qna/                        # Common questions and deep dives
    ├── push-pop-explained.md
    ├── int-vs-syscall.md
    ├── memory-addressing.md
    └── sections-and-optimization.md

🎯 Complete Curriculum

LEVEL 1: Foundation (Weeks 1-2)

✅ Topic 1: Setup & First Program

✅ Topic 2: Registers & Data Types

📚 Supplementary: Instruction Encoding

✅ Topic 3: Basic Instructions

LEVEL 2: Control Flow (Weeks 3-4)

✅ Topic 4: Flags & Comparisons

✅ Topic 5: Conditional Jumps

✅ Topic 6: Loops

LEVEL 3: The Stack (Week 5)

✅ Topic 7: Stack Operations

✅ Topic 8: Stack Frames

LEVEL 4: Functions & Procedures (Weeks 6-7)

✅ Topic 9: Calling Conventions

✅ Topic 10: Procedures

LEVEL 5: Memory & Addressing (Week 8)

✅ Topic 11: Memory Addressing Modes

✅ Topic 12: Arrays & Strings

LEVEL 6: Advanced Operations (Weeks 9-10)

✅ Topic 13: Multiplication & Division

✅ Topic 14: Shifts & Rotates (Advanced)

✅ Topic 15: Macros & Directives

LEVEL 7: System Programming (Weeks 11-12)

✅ Topic 16: Linux System Calls

✅ Topic 17: Interfacing with C

LEVEL 8: Optimization & Advanced (Weeks 13-14)

✅ Topic 18: SIMD Instructions

✅ Topic 19: Performance & Optimization

✅ Topic 20: Debugging & Tools

❓ Q&A Section - Deep Dives

These files contain detailed explanations of specific questions that came up during learning:

  1. Push and Pop Explained
    • Stack mechanics
    • LIFO behavior
    • Swapping values with push/pop
  2. int 0x80 vs syscall
    • When to use each
    • Register differences
    • Syscall number differences
    • Performance implications
  3. Memory Addressing with [ ] Brackets
    • Dereferencing explained
    • All addressing modes
    • Practical examples
    • Common mistakes
  4. Sections (.text, .data, .bss) and XOR Optimization
    • Memory layout
    • Section purposes
    • Relation to C code
    • Why xor reg, reg is better than mov reg, 0
  5. CMP vs TEST - What’s the Difference?
    • CMP does subtraction, TEST does AND
    • When to use each instruction
    • Performance comparison
    • Common mistakes and decision tree
  6. Linux x86-64 Syscall Reference
    • Complete syscall register usage (RAX, RDI, RSI, RDX, R10, R8, R9)
    • Common syscalls with examples (read, write, open, close, exit)
    • File I/O, process control, memory management
    • Complete syscall number tables
    • Error handling and return values
    • Practical examples for each syscall
  7. All Types of Jumps - Complete Reference
    • Unconditional jumps (JMP)
    • Conditional jumps: signed (JG, JL, etc.) and unsigned (JA, JB, etc.)
    • Flag-specific jumps (JZ, JS, JC, JO, JP)
    • Loop instructions (LOOP, LOOPE, LOOPNE)
    • Function calls (CALL/RET)
    • Indirect jumps and jump tables (switch statements)
    • Conditional move (CMOVcc) as branchless alternative
    • Complete reference table with all 40+ jump variants
    • Performance optimization patterns
  8. Instruction Size (Bytes) vs Execution Time (Cycles)
    • Why we measure BOTH bytes and cycles
    • Bytes = space in memory (code size, cache efficiency)
    • Cycles = execution time (performance, speed)
    • How instruction size affects I-cache performance
    • Real-world examples showing both measurements matter
    • When to optimize for bytes vs cycles
    • Measuring techniques for each (objdump, RDTSC, perf)
    • Complete comparison with benchmarks

🎓 Progress Tracking

✅ Foundation (Weeks 1-2):

✅ Control Flow (Weeks 3-4):

✅ The Stack (Week 5):

✅ Functions & Procedures (Weeks 6-7):

✅ Memory & Addressing (Week 8):

✅ Advanced Operations (Weeks 9-10):

✅ System Programming (Weeks 11-12):

✅ Optimization & Advanced (Weeks 13-14):

Supplementary:

🎉 ALL 20 TOPICS COMPLETED! Over 30,000 lines of comprehensive content!

📖 How to Use This Tutorial

  1. Sequential Learning: Follow topics in order - each builds on previous knowledge
  2. Hands-On Practice: Type and run every code example
  3. Complete Exercises: Practice problems reinforce concepts
  4. Check Understanding: Review knowledge checks before moving on
  5. Reference Q&A: Deep dive into specific questions as needed

🛠️ Prerequisites

📝 Quick Command Reference

# Assemble 64-bit
nasm -f elf64 program.asm -o program.o

# Link
ld -o program program.o

# Run
./program

# Check exit code
echo $?

# Assemble with debug info
nasm -f elf64 -g -F dwarf program.asm

# Debug with GDB
gdb ./program

🎯 Learning Goals

By completing this course, you will be able to:

✅ Write complete assembly programs from scratch ✅ Understand x86-64 architecture deeply ✅ Read and understand compiler output ✅ Optimize code at the lowest level ✅ Debug assembly with confidence ✅ Interface assembly with high-level languages ✅ Work with system calls and OS interfaces ✅ Apply assembly knowledge to reverse engineering and security

📚 Additional Resources

🤝 Contributing

Found an error? Have a question? Want to add content? Feel free to modify and extend these materials!

Current Status: 🎉 ALL 20 TOPICS COMPLETED! Over 30,000 lines of comprehensive NASM assembly programming content with C equivalents throughout!

Happy Assembly Programming! 🚀