The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Basic Syntax and Structure

Next ►
►

In this section, we will cover the fundamental syntax and structure of assembly language programs. Understanding these basics is crucial for writing and reading assembly code effectively.

Key Concepts

  1. Assembly Language Structure:

    • Labels: Used to mark a position in the code.
    • Instructions: Commands executed by the CPU.
    • Directives: Instructions to the assembler, not the CPU.
    • Comments: Non-executable text for documentation.

  2. Basic Syntax:

    • Instruction Format: Typically consists of an opcode and operands.
    • Operands: Can be registers, memory addresses, or immediate values.

  3. Common Directives:

    • .data: Section for declaring initialized data.
    • .bss: Section for declaring uninitialized data.
    • .text: Section for the actual code.

Assembly Language Structure

Labels

Labels are used to identify a location in the code. They are typically followed by a colon (:).

start:
    ; Code goes here

Instructions

Instructions are the commands that the CPU executes. They usually consist of an opcode and one or more operands.

mov eax, 1  ; Move the value 1 into the EAX register
add eax, 2  ; Add 2 to the value in the EAX register

Directives

Directives provide instructions to the assembler. They are not executed by the CPU but are essential for organizing the code.

section .data
    message db 'Hello, World!', 0

section .text
    global _start

_start:
    ; Code goes here

Comments

Comments are used to explain the code and are ignored by the assembler. They start with a semicolon (;).

; This is a comment
mov eax, 1  ; Move the value 1 into the EAX register

Basic Syntax

Instruction Format

An instruction typically consists of an opcode followed by operands.

opcode operand1, operand2

Operands

Operands can be:

  • Registers: Small storage locations within the CPU.
  • Memory Addresses: Locations in RAM.
  • Immediate Values: Constant values directly specified in the instruction.
mov eax, ebx  ; Move the value in EBX to EAX
mov eax, [ebx] ; Move the value at the memory address in EBX to EAX
mov eax, 10   ; Move the value 10 into EAX

Common Directives

.data Section

The .data section is used for declaring initialized data.

section .data
    message db 'Hello, World!', 0  ; Declare a string

.bss Section

The .bss section is used for declaring uninitialized data.

section .bss
    buffer resb 64  ; Reserve 64 bytes for a buffer

.text Section

The .text section is used for the actual code.

section .text
    global _start

_start:
    ; Code goes here

Practical Example

Let's write a simple assembly program that prints "Hello, World!" to the console.

section .data
    message db 'Hello, World!', 0  ; The string to print

section .text
    global _start

_start:
    ; Write the message to stdout
    mov eax, 4          ; syscall number for sys_write
    mov ebx, 1          ; file descriptor 1 is stdout
    mov ecx, message    ; pointer to the message
    mov edx, 13         ; length of the message
    int 0x80            ; call the kernel

    ; Exit the program
    mov eax, 1          ; syscall number for sys_exit
    xor ebx, ebx        ; exit code 0
    int 0x80            ; call the kernel

Explanation

  1. Data Section:

    • message db 'Hello, World!', 0: Declares a string with a null terminator.

  2. Text Section:

    • global _start: Defines the entry point.
    • _start:: Label marking the start of the program.
    • mov eax, 4: Sets up the syscall number for sys_write.
    • mov ebx, 1: Sets the file descriptor to stdout.
    • mov ecx, message: Points to the message.
    • mov edx, 13: Sets the length of the message.
    • int 0x80: Makes the syscall.
    • mov eax, 1: Sets up the syscall number for sys_exit.
    • xor ebx, ebx: Sets the exit code to 0.
    • int 0x80: Makes the syscall.

Exercises

Exercise 1: Print a Different Message

Modify the example program to print "Hello, Assembly!" instead of "Hello, World!".

Solution:

section .data
    message db 'Hello, Assembly!', 0  ; The new string to print

section .text
    global _start

_start:
    ; Write the message to stdout
    mov eax, 4
    mov ebx, 1
    mov ecx, message
    mov edx, 15         ; Updated length of the new message
    int 0x80

    ; Exit the program
    mov eax, 1
    xor ebx, ebx
    int 0x80

Exercise 2: Add Two Numbers

Write an assembly program that adds two numbers and stores the result in a register.

Solution:

section .text
    global _start

_start:
    mov eax, 5          ; First number
    mov ebx, 3          ; Second number
    add eax, ebx        ; Add EBX to EAX, result in EAX

    ; Exit the program
    mov eax, 1
    xor ebx, ebx
    int 0x80

Summary

In this section, we covered the basic syntax and structure of assembly language programs, including labels, instructions, directives, and comments. We also wrote a simple program to print a message to the console and provided exercises to reinforce the concepts. Understanding these basics is essential for progressing to more complex assembly programming topics.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved