Tổng quan về giáo trình

Giáo trình "Hướng Dẫn Lập Trình Assembly Cơ Bản" do tác giả Đỗ Thanh Nghị (dtnghi@cit.vn) biên soạn (phiên bản tháng 12/2019, cập nhật tháng 01/2020), là tài liệu học tập dành cho học phần Lập trình Hợp ngữ và Kiến trúc Máy tính thuộc khối ngành Công nghệ Thông tin, Kỹ thuật Phần mềm và Kỹ thuật Máy tính. Tài liệu định vị môn học ở tầng trung gian giữa phần cứng máy tính và các ngôn ngữ lập trình bậc cao, giúp người học hiểu rõ nguyên lý vận hành của vi xử lý, không gian bộ nhớ và hệ thống ngắt của hệ điều hành.

Mục tiêu học tập của giáo trình được xác định cụ thể bao gồm:

  • Phân biệt các mô hình kiến trúc tập lệnh vi xử lý (CISC và RISC).
  • Nắm vững cấu trúc một chương trình hợp ngữ chuẩn trên hệ điều hành Linux (.data, .bss, .text).
  • Hiểu và thao tác với không gian bộ nhớ (Memory Layout) cùng hệ thống thanh ghi 16-bit, 32-bit và 64-bit.
  • Sử dụng thành thạo các lệnh di chuyển dữ liệu, tính toán số học, phép toán luận lý, rẽ nhánh điều kiện, vòng lặp, quản lý mảng và thủ tục.
  • Thực hiện tương tác với nhân hệ điều hành thông qua cơ chế lời gọi hệ thống (Linux System Calls) bằng ngắt phần mềm int 0x80.

Về cách tiếp cận, giáo trình áp dụng mô hình phân tích lý thuyết kiến trúc phần cứng kết hợp lập trình thực nghiệm trên nền tảng The Netwide Assembler (NASM v2.01) và trình liên kết ld (GNU Linker). Cấu trúc bài giảng đi từ việc định nghĩa phần cứng, tổ chức bộ nhớ đến các ví dụ thực thi mã nguồn hoàn chỉnh. Điểm đặc thù của tài liệu là chuẩn hóa toàn bộ các ví dụ trên môi trường Linux 32-bit (elf32), sử dụng cú pháp Intel trực quan và tích hợp các môi trường hợp dịch trực tuyến (Online Asm Compiler/IDE).

Nội dung kiến thức cốt lõi

+-------------------------------------------------------------------------+
|                  CẤU TRÚC PHÂN PHỐI BỘ NHỚ CHƯƠNG TRÌNH                 |
+-------------------------------------------------------------------------+
|  High Memory  | [ Stack ]            -> Chứa dữ liệu hàm, biến cục bộ   |
|               | [ . ]                -> Vùng co giãn                    |
|               | [ Heap ]             -> Cấp phát động                   |
|               | [ BSS ]              -> Biến chưa khởi tạo (.bss)       |
|               | [ Data ]             -> Dữ liệu khởi tạo, hằng (.data)  |
|               | [ Text / Code ]      -> Mã máy thực thi (.text)         |
|  Low Memory   | [ Reserved ]         -> Vùng nhớ dành riêng cho OS      |
+-------------------------------------------------------------------------+

Các chương/chủ đề chính

Tài liệu được chia thành các phần nội dung có tính kế thừa và phát triển logic:

  1. Tổng quan về Hợp ngữ và Kiến trúc Máy tính: Phân loại kiến trúc vi xử lý thành CISC (Complex Instruction Set Computer) điển hình là họ x86 và RISC (Reduced Instruction Set Computer) như ARM, MIPS. Giới thiệu các bộ công cụ hợp dịch phổ biến: Microsoft Assembler (MASM), Borland Turbo Assembler (TASM), The GNU Assembler (GAS) và The Netwide Assembler (NASM).
  2. Cấu trúc Chương trình và Phân đoạn Bộ nhớ: Phân tích sơ đồ bố cục bộ nhớ (Memory Layout) từ vùng nhớ thấp đến vùng nhớ cao (Reserved -> Text -> Data -> BSS -> Heap -> Stack). Quy định vai trò của 3 phân đoạn cơ bản:
    • section .data: Khai báo dữ liệu đã khởi tạo và định nghĩa hằng số.
    • section .bss: Cấp phát vùng nhớ cho biến chưa khởi tạo.
    • section .text: Chứa mã lệnh thực thi, khai báo nhãn toàn cục global _start làm điểm nhập (Entry point) cho trình liên kết.
  3. Quy trình Hợp dịch và Liên kết (Assembly & Linking): Các bước biên dịch từ mã nguồn Assembly sang tập tin đối tượng (.o) và liên kết thành tập tin thực thi:
    • Lệnh hợp dịch: nasm -f elf32 hello.asm (hoặc -f elf64).
    • Lệnh liên kết: ld -m elf_i386 -s -o hello hello.o.
  4. Hệ thống Thanh ghi (Processor Registers):
    • Thanh ghi dữ liệu tổng quát: Phân cấp 16-bit (AX, BX, CX, DX), 32-bit mở rộng (EAX, EBX, ECX, EDX) và 64-bit (RAX, RBX, RCX, RDX).
    • Thanh ghi con trỏ và chỉ mục: Con trỏ lệnh (IP, EIP, RIP), con trỏ ngăn xếp (SP, ESP, RSP), con trỏ nền (BP, EBP, RBP), chỉ mục nguồn (SI, ESI, RSI) và chỉ mục đích (DI, EDI, RDI).
    • Thanh ghi cờ điều khiển (Flags): OF (Tràn), ZF (Không), SF (Dấu), CF (Nhớ), PF (Chẵn lẻ), DF (Hướng), IF (Ngắt), TF (Bẫy).
    • Thanh ghi đoạn: CS (Code Segment), DS (Data Segment), SS (Stack Segment).
  5. Lời gọi Hệ thống Linux (Linux System Calls): Cơ chế gọi hàm hệ điều hành thông qua ngắt mềm int 0x80:
    • Nạp mã số hệ thống vào thanh ghi EAX (ví dụ: sys_exit = 1, sys_read = 3, sys_write = 4).
    • Truyền tham số thông qua EBX (file descriptor: 0 là stdin, 1 là stdout), ECX (địa chỉ bộ đệm dữ liệu) và EDX (độ dài dữ liệu/chuỗi).
  6. Chế độ Định địa chỉ, Biến và Hằng:
    • Các mode định địa chỉ: Địa chỉ thanh ghi, địa chỉ tức thời và địa chỉ bộ nhớ.
    • Cú pháp lệnh gán dữ liệu mov dest, src.
    • Khai báo biến với chỉ thị dữ liệu (db, dd, resb, toán tử lặp times) và định nghĩa hằng số bằng chỉ thị equ (ví dụ: len equ $ - msg).
  7. Các Phép toán Số học và Luận lý:
    • Lệnh tăng/giảm: inc dest, dec dest.
    • Phép cộng/trừ: add dest, src, sub dest, src trên các chế độ thanh ghi - thanh ghi, bộ nhớ - thanh ghi, thanh ghi - hằng số.
    • Phép nhân/chia: mul/imul multiplier, div/idiv divisor thao tác trên thanh ghi AL, AX, EAX.
    • Xử lý chuyển đổi qua lại giữa số nguyên và ký tự hiển thị ASCII bằng cách cộng/trừ với '0'.
  8. Cấu trúc Rẽ nhánh, Vòng lặp, Mảng và Thủ tục:
    • Lệnh so sánh cmp dest, src kết hợp lệnh nhảy có điều kiện (jg, jnz) và không điều kiện (jmp).
    • Cấu trúc lặp với lệnh loop label, kết hợp chỉ thị push ecx và pop ecx để bảo toàn giá trị biến đếm trong thanh ghi khi gọi ngắt hệ thống.
    • Khai báo và duyệt mảng số nguyên tuần tự bằng con trỏ địa chỉ.
    • Định nghĩa chương trình con và lời gọi thủ tục thông qua lệnh call.
+-------------------------------------------------------------------------+
|                  BẢNG ÁNH XẠ THANH GHI VÀ LỜI GỌI HỆ THỐNG LINUX        |
+-------------------------------------------------------------------------+
| Thanh ghi | Vai trò trong Lời gọi Hệ thống (int 0x80)                   |
+-----------+-------------------------------------------------------------+
| EAX       | Lưu mã định danh lời gọi (1: sys_exit, 3: sys_read, 4: sys_write) |
| EBX       | File Descriptor (0: stdin, 1: stdout, 2: stderr)            |
| ECX       | Địa chỉ con trỏ vùng đệm nhớ chứa dữ liệu (Buffer Address)  |
| EDX       | Độ dài khối dữ liệu tính theo byte (Length/Size)            |
+-------------------------------------------------------------------------+

Kiến thức nền tảng được xây dựng

Giáo trình xây dựng hệ thống nền tảng bao gồm:

  • Kiến trúc tập lệnh x86: Hiểu rõ quy tắc lưu trữ dữ liệu, cách CPU giải mã lệnh và tương tác với hệ thống bus, thanh ghi và bộ nhớ.
  • Tổ chức không gian địa chỉ ảo: Cách hệ điều hành Linux quản lý và phân vùng không gian nhớ cho một tiến trình thực thi.
  • Giao diện lập trình mức thấp (Kernel Interface): Bản chất của các tương tác nhập/xuất (I/O) từ không gian người dùng (User Space) vào không gian nhân (Kernel Space) qua bảng ngắt hệ thống.

Kỹ năng phát triển

  • Kỹ năng kỹ thuật: Viết mã nguồn hợp ngữ NASM chuẩn; thực hiện quy trình hợp dịch và liên kết trên môi trường dòng lệnh Linux; quản lý và sử dụng tối ưu hệ thống thanh ghi.
  • Kỹ năng phân tích: Phân tích logic rẽ nhánh ở mức thanh ghi cờ (EFLAGS), tính toán địa chỉ vùng nhớ và chuyển đổi các kiểu dữ liệu thô (chuỗi byte, mã ASCII, số nguyên).
  • Kỹ năng thực hành: Xây dựng các giải thuật cơ bản ở mức thấp như: tìm phần tử lớn nhất trong danh sách, tính tổng mảng, lặp khối dữ liệu và phân tách mã nguồn thành các hàm/thủ tục độc lập.

Phương pháp giảng dạy và học tập

Giáo trình được thiết kế theo phương pháp sư phạm tiếp cận trực quan và thực hành song song với lý thuyết. Mỗi chủ đề đều được xây dựng theo chu trình: Giải thích cơ chế phần cứng -> Mô tả cú pháp lệnh -> Minh họa bằng mã nguồn hoàn chỉnh -> Phân tích kết quả thực thi trên thanh ghi và bộ nhớ.

+-------------------------------------------------------------------------+
|                       QUY TRÌNH BIÊN DỊCH VÀ LIÊN KẾT                   |
+-------------------------------------------------------------------------+
|  [ File nguồn .asm ]  -- (nasm -f elf32) -->  [ File đối tượng .o ]     |
|                                                       |                 |
|                                                  (ld -m elf_i386)       |
|                                                       v                 |
|  [ Thực thi ./binary ] <--------------------- [ File thực thi ]         |
+-------------------------------------------------------------------------+

Các bài tập và ví dụ thực hành được trích xuất trực tiếp từ tài liệu:

  • Ví dụ xuất chuỗi cơ bản (hello.asm): Minh họa cấu trúc khung chương trình, sử dụng sys_write (mã 4) và sys_exit (mã 1) với ngắt int 0x80.
  • Ví dụ nhập/xuất dữ liệu (system_calls.asm): Thực hiện nhắc người dùng nhập một chuỗi số (sys_write), đọc dữ liệu vào vùng đệm num resb 5 (sys_read với ebx = 0), và in chuỗi vừa nhập ra màn hình.
  • Ví dụ thao tác bộ nhớ (addressing.asm): Ghi đè giá trị bộ nhớ tại nhãn name bằng lệnh mov [name], dword 'Nuha' để thay đổi chuỗi ký tự khởi tạo ban đầu.
  • Ví dụ số học (arithmetic.asm):
    • Phép cộng hai số dạng ký tự '3' và '4', thực hiện trừ mã ASCII '0', cộng giá trị qua thanh ghi eax, ebx và chuyển đổi lại thành ký tự để hiển thị.
    • Phép nhân hai số 8-bit bằng lệnh mul bl (với al = '3', bl = '2').
    • Phép chia 16-bit/8-bit bằng lệnh div bl (với ax = '8', bl = '2').
  • Ví dụ cấu trúc điều kiện (conditions.asm): Tìm giá trị lớn nhất trong ba biến số num1 dd '47', num2 dd '22', num3 dd '31' bằng chuỗi lệnh so sánh cmp và nhảy có điều kiện jg.
  • Ví dụ cấu trúc lặp (loops.asm): In dãy ký tự từ 1 đến 10 bằng lệnh loop, áp dụng kỹ thuật đẩy giá trị thanh ghi ECX vào ngăn xếp bằng push ecx trước khi gọi ngắt int 0x80 và khôi phục bằng pop ecx.
  • Ví dụ xử lý mảng (arrays.asm): Duyệt mảng x db 2, 4, 3, sử dụng thanh ghi ECX làm con trỏ địa chỉ, tịnh tiến con trỏ bằng add ecx, 1 và tính tổng các phần tử vào thanh ghi EBX.
  • Ví dụ thủ tục (procedures.asm): Chuyển giao luồng điều khiển sang nhãn sum bằng lệnh call sum để tính toán và lưu kết quả vào biến res.

Về đánh giá và tự học, giáo trình yêu cầu người học kiểm tra kết quả từng dòng lệnh thông qua việc quan sát trạng thái ngõ ra (stdout) và giá trị trả về của tiến trình. Tài liệu cung cấp hướng dẫn sử dụng công cụ kiểm thử trực tuyến (Online Asm IDE v2.01) giúp người học thực hành trực tiếp trên trình duyệt mà không cần cài đặt phức tạp.

Điểm nổi bật và cập nhật

  • Chuẩn hóa cú pháp Intel với NASM: Giáo trình sử dụng trình hợp dịch NASM trên nền tảng Linux thay vì cú pháp AT&T phức tạp của trình hợp dịch GAS, giúp mã nguồn tường minh hơn theo định dạng Lệnh Đích, Nguồn (mov dest, src).
  • Phân định rõ ràng tiến trình tiến hóa thanh ghi: Tài liệu xây dựng bảng phân cấp chi tiết quá trình phát triển của họ vi xử lý Intel từ 16-bit (gốc AX, BX, CX, DX), mở rộng lên 32-bit (tiền tố Extended EAX, EBX, ECX, EDX) đến 64-bit (tiền tố Register RAX, RBX, RCX, RDX).
  • Tiếp cận lập trình hệ thống trực tiếp qua Kernel System Calls: Loại bỏ sự phụ thuộc vào các thư viện chuẩn C runtime (libc) trong các bài toán cơ bản. Việc sử dụng trực tiếp ngắt int 0x80 giúp người học nắm vững cách phần mềm tương tác với nhân hệ điều hành Linux.
  • Mô hình hóa trực quan không gian bộ nhớ: Cung cấp sơ đồ cấu trúc bộ nhớ chuẩn (Illustration 4: General Memory Layout), phân định ranh giới giữa vùng nhớ dành riêng cho hệ điều hành (Reserved section), vùng mã máy (Text/Code), vùng dữ liệu (Data/BSS) và vùng động (Heap/Stack).

Đối tượng sử dụng giáo trình

  • Sinh viên đại học/cao đẳng: Sinh viên năm thứ nhất hoặc năm thứ hai thuộc các ngành Khoa học Máy tính, Kỹ thuật Máy tính, Công nghệ Thông tin, An toàn Thông tin đang theo học các học phần Kiến trúc Máy tính, Hợp ngữ hoặc Hệ điều hành.
  • Yêu cầu kiến thức tiên quyết (Prerequisites):
    • Kiến thức toán rời rạc và hệ thống số cơ bản: Hệ nhị phân (Binary), hệ thập lục phân (Hexadecimal), mã ASCII, phép toán bitwise (AND, OR, XOR, NOT).
    • Khái niệm cơ bản về kiến trúc phần cứng máy tính: CPU, RAM, ngăn xếp (Stack), bus dữ liệu và con trỏ lệnh.
    • Kỹ năng thao tác dòng lệnh (Command Line Interface - CLI) cơ bản trên hệ điều hành Linux.
  • Giảng viên và kỹ thuật viên phòng thí nghiệm: Dùng làm đề cương bài giảng lý thuyết, giáo án thực hành phòng máy và nguồn bài tập mẫu cho các học phần liên quan đến cấu trúc hệ thống máy tính.
  • Người tự học và nghiên cứu kỹ thuật: Lập trình viên muốn tìm hiểu sâu về kỹ thuật dịch ngược (Reverse Engineering), khai thác lỗ hổng bảo mật mức nhị phân (Binary Exploitation), tối ưu hóa hiệu năng thuật toán hoặc phát triển nhân hệ điều hành.

Câu hỏi thường gặp

1. Giáo trình này phù hợp với ai?

Tài liệu phù hợp nhất với sinh viên chuyên ngành Công nghệ Thông tin, Kỹ thuật Máy tính và các kỹ sư phần mềm muốn nghiên cứu sâu về kiến trúc máy tính, nguyên lý hoạt động của CPU x86 và giao tiếp mức thấp với nhân Linux.

2. Cần chuẩn bị kiến thức nền tảng nào trước khi học?

Người học cần nắm vững biểu diễn số nhị phân, số thập lục phân, bảng mã ký tự ASCII, nguyên lý hoạt động cơ bản của hệ điều hành và các lệnh cơ bản trong terminal Linux (gcc, ld, lệnh thực thi tệp tin).

3. Điểm khác biệt của giáo trình này so với các tài liệu Assembly khác là gì?

Tài liệu tập trung vào lập trình hợp ngữ 32-bit trên hệ điều hành Linux bằng trình hợp dịch NASM và gọi ngắt hệ thống int 0x80. Cách tiếp cận này hiện đại hơn các tài liệu giảng dạy hợp ngữ 16-bit trên nền DOS/MASM cũ, đồng thời loại bỏ sự phức tạp của cú pháp AT&T.

4. Làm sao để tự học và thực hành hiệu quả theo giáo trình?

Người học có thể cài đặt hệ thống Linux (Ubuntu/Debian) kèm gói công cụ nasm và binutils (chứa ld), hoặc sử dụng các trình biên dịch Assembly trực tuyến (Online NASM IDE) theo các liên kết thực hành được cung cấp trong tài liệu để viết mã và chạy thử từng ví dụ.

5. Có những công cụ hợp dịch nào được đề cập trong tài liệu?

Tài liệu liệt kê bốn trình hợp dịch phổ biến cho kiến trúc x86 bao gồm: MASM (Microsoft Assembler), TASM (Borland Turbo Assembler), GAS (GNU Assembler) và NASM (The Netwide Assembler). Trong đó, toàn bộ bài tập và mã nguồn minh họa đều được chuẩn hóa theo cú pháp của NASM v2.01.

Kết luận

Giáo trình "Hướng Dẫn Lập Trình Assembly Cơ Bản" của tác giả Đỗ Thanh Nghị là tài liệu học thuật tổng hợp đầy đủ các nguyên lý cốt lõi về lập trình hợp ngữ x86 trên nền tảng Linux. Tài liệu cung cấp hệ thống kiến thức chuẩn xác từ cấu trúc phân bổ bộ nhớ, quản lý thanh ghi đến kỹ thuật điều khiển luồng dữ liệu và tương tác trực tiếp với nhân hệ điều hành qua các lời gọi hệ thống. Lộ trình học tập được thiết kế mạch lạc, kết hợp giữa sơ đồ lý thuyết và mã nguồn mẫu chi tiết, tạo nền tảng vững chắc cho người học trong việc tiếp cận các lĩnh vực chuyên sâu như lập trình hệ thống, phát triển trình biên dịch và phân tích mã độc.