Chapter 3: Data Segments and Directives

Segmentation in Assembly

In assembly language programming, segmentation refers to the organizational structure of memory into segments, each serving specific purposes within the program. Segments provide a way to manage and access memory efficiently by dividing it into logical units, such as code, data, and stack segments.

Segments in assembly are defined using segment directives, which specify the attributes and characteristics of each segment. For example, the “SEGMENT” directive is used to declare the beginning of a segment, indicating whether it contains code (CODE SEGMENT), data (DATA SEGMENT), or stack (STACK SEGMENT) information.

Each segment directive is followed by its corresponding segment block, where programmers define variables, constants, and arrays. For instance, within a DATA SEGMENT, variables like integers, characters, and arrays can be declared to allocate memory space.

Understanding segmentation is crucial for efficiently managing memory resources in assembly programming. It allows programmers to organize their code and data logically, facilitating easier debugging, maintenance, and optimization of programs. Moreover, segmentation provides a structured approach to memory management, enhancing the overall performance and reliability of assembly language applications.

Understanding the concept of segments: data, code, and stack segments.

Understanding the concept of segments is fundamental in assembly language programming. Segments divide memory into distinct sections, each designated for specific types of data or instructions, ensuring organized and efficient memory management.

Data segments store variables and constants used in a program. Within a data segment, you can define different data types such as integers, characters, and arrays. This segment is essential for holding the data that the program manipulates during its execution. For instance, you might declare a variable within a data segment to store the user’s input or to keep track of a counter in a loop.

Code segments contain the executable instructions of a program. When a program runs, the processor fetches and executes the instructions from the code segment. This segment is crucial as it holds the actual logic and functionality of the program. For example, the code segment includes instructions for arithmetic operations, data movement, and control flow like loops and conditionals.

Stack segments are used for managing function calls and local variables. The stack operates in a last-in, first-out (LIFO) manner, where data is pushed onto the stack and popped off the stack as needed. This segment is vital for maintaining the call stack, storing return addresses, and handling local variables during function execution. For example, when a function is called, its return address and parameters are pushed onto the stack, ensuring the program can return to the correct location after the function executes.

Understanding these segments—data, code, and stack—helps programmers efficiently organize their code and manage memory resources in assembly language programs. This segmentation enhances program clarity, eases debugging, and improves overall performance by structuring the program into manageable and distinct sections.

Defining and using segments in TASM

Defining and using segments in TASM (Turbo Assembler) is a critical part of structuring your assembly language program. Segments help in organizing the program into logical parts, making it easier to manage data, code, and the stack. Here’s a detailed explanation of how to define and use segments in TASM:

Defining Segments in TASM

To define a data segment, use the “DATA SEGMENT” directive followed by variable declarations, and end it with the “DATA ENDS” directive. For example, you can define an 8-bit variable using “var1 DB 10” and a 16-bit variable using “var2 DW 20”. Strings can also be defined, such as “message DB ‘Hello, World!’, ‘$’” with a terminating character.

In the code segment, use the “CODE SEGMENT” directive to start, write your code, and close it with the “CODE ENDS” directive. For example, you can use “ASSUME CS, DS” to assume the code segment and data segment. To print a string, move the data segment address to AX with “MOV AX, DATA”, set DS to AX with “MOV DS, AX”, and use DOS functions like “MOV AH, 09H” to print a string and “LEA DX, message” to load the effective address of the message into DX. Finally, use “INT 21H” to call DOS interrupt to print the string and terminate the program with “MOV AX, 4C00H” and “INT 21H”.

For the stack segment, define it using the “STACK SEGMENT” directive and specify the stack size. For example, use “DB 100H DUP(0)” to define a stack with 256 bytes.

Using Segments in TASM

After defining segments, set up segment registers and make appropriate references. Initialize the segment registers (DS for data segment, CS is automatically set for code segment) by loading the data segment address into AX with “MOV AX, DATA” and setting DS register to the data segment address with “MOV DS, AX”. Access variables defined in the data segment using direct or indirect addressing modes, such as “MOV AL, var1” to move the value of var1 into AL.

Use the stack segment for function calls, pushing and popping data. For example, push AX onto the stack with “PUSH AX”, call a function with “CALL MyFunction”, and pop AX from the stack with “POP AX”. Define functions using “MyFunction PROC” and “MyFunction ENDP”, and use “RET” to return from the function.

Complete Example

Here’s a complete example combining all segments:

assembly

; Define data segment
DATA SEGMENT
    message DB 'Hello, World!', '$'
    var1 DB 10
DATA ENDS

; Define stack segment
STACK SEGMENT
    DB 100H DUP(0)
STACK ENDS

; Define code segment
CODE SEGMENT
    ASSUME CS:CODE, DS:DATA

START:
    MOV AX, DATA      ; Initialize data segment register
    MOV DS, AX
    MOV AH, 09H       ; DOS function to print a string
    LEA DX, message   ; Load address of the message
    INT 21H           ; Call DOS interrupt to print
    MOV AX, 4C00H     ; DOS function to terminate program
    INT 21H           ; Call DOS interrupt to terminate

CODE ENDS

END START

In this example, the program prints “Hello, World!” to the screen. The data segment contains the string message, the stack segment is allocated but not used in this simple example, and the code segment contains the program logic. This structure helps in managing the program efficiently and understanding the flow of execution.

Assembly Language Directives

Assembly language directives are special instructions that provide guidance to the assembler on how to process the code. These directives do not generate machine code themselves but influence how the assembler translates the program. Understanding and using these directives effectively is crucial for writing clear and efficient assembly language programs in TASM (Turbo Assembler). Here’s a detailed exploration of some common assembly language directives:

ORG Directive

The ORG directive sets the starting address for the code or data segment. This is particularly useful when you need to control where certain parts of your program are loaded in memory.

Example:

assembly

ORG 100h
MOV AX, 1234h

This code sets the starting address of the following instructions to 100h.

DB, DW, DD Directives

These directives are used to define initialized data in memory. DB (Define Byte), DW (Define Word), and DD (Define Double Word) are used to allocate memory and initialize it with specified values.

Example:

assembly

DATA SEGMENT
    myByte DB 0FFh         ; Define a byte with value 0FFh
    myWord DW 1234h        ; Define a word with value 1234h
    myDWord DD 12345678h   ; Define a double word with value 12345678h
DATA ENDS

SEGMENT and ENDS Directives

These directives are used to define a segment. The SEGMENT directive marks the beginning of a segment, and the ENDS directive marks the end of it.

Example:

assembly

DATA SEGMENT
    myData DB 'Hello', 0
DATA ENDS

CODE SEGMENT
    ; Your code here
CODE ENDS

ASSUME Directive

The ASSUME directive tells the assembler which segments should be associated with the segment registers. This is necessary for correctly addressing memory locations.

Example:

assembly

ASSUME CS:CODE, DS:DATA

EQU Directive

The EQU directive is used to define constants. It assigns a constant value to a symbol, which can then be used throughout the program.

Example:

assembly

PI EQU 3.14
MOV AX, PI

In this example, PI is defined as 3.14, and it can be used in place of the constant value.

END Directive

The END directive marks the end of the source code. It is necessary for the assembler to know where the program ends.

Example:

assembly

END START

PROC and ENDP Directives

The PROC directive is used to define a procedure (or function), and the ENDP directive marks the end of the procedure. These are used to structure code into reusable blocks.

Example:

assembly

MyProcedure PROC
    ; Procedure code here
    RET
MyProcedure ENDP

PUBLIC and EXTERN Directives

The PUBLIC directive makes a procedure or variable available to other modules, while the EXTERN directive declares an external procedure or variable defined in another module.

Example:

assembly

PUBLIC MyProcedure
EXTERN OtherProcedure:NEAR

Practical Example

Combining these directives, let’s create a simple program that includes a data segment, code segment, and a procedure to print a string.

assembly

; Define data segment
DATA SEGMENT
    message DB 'Hello, World!', '$'
DATA ENDS

; Define stack segment
STACK SEGMENT
    DB 100H DUP(0)
STACK ENDS

; Define code segment
CODE SEGMENT
    ASSUME CS:CODE, DS:DATA

START:
    MOV AX, DATA      ; Initialize data segment register
    MOV DS, AX
    CALL PrintMessage ; Call the procedure to print the message
    MOV AX, 4C00H     ; DOS function to terminate program
    INT 21H           ; Call DOS interrupt to terminate

PrintMessage PROC
    MOV AH, 09H       ; DOS function to print a string
    LEA DX, message   ; Load address of the message
    INT 21H           ; Call DOS interrupt to print
    RET
PrintMessage ENDP

CODE ENDS

END START

In this example, we define a data segment containing a message, a code segment with the main program and a procedure, and we use various directives like ASSUME, DB, PROC, ENDP, and END to structure the program. This makes the code organized, readable, and easy to manage.

Explanation of Common Directives: SEGMENT, ENDS, ASSUME, and More

Assembly language directives are essential tools that guide the assembler on how to process the code. Unlike assembly instructions that generate machine code, directives help in organizing and managing the code without producing executable instructions themselves. Understanding these directives is crucial for efficient assembly language programming. Here’s a detailed explanation of some common directives used in TASM (Turbo Assembler):

SEGMENT and ENDS Directives

The SEGMENT directive marks the beginning of a segment. Segments are logical units of memory that can contain code, data, or stack information. The ENDS directive marks the end of a segment. Segmentation helps in organizing the program into distinct parts.

Example:

assembly

DATA SEGMENT
    myData DB 'Hello, World!', 0
DATA ENDS

CODE SEGMENT
    ; Your code here
CODE ENDS

In this example, DATA SEGMENT and DATA ENDS define a data segment, while CODE SEGMENT and CODE ENDS define a code segment.

ASSUME Directive

The ASSUME directive tells the assembler which segments should be associated with the segment registers (CS, DS, SS, ES). This is necessary for correctly addressing memory locations.

Example:

assembly

ASSUME CS:CODE, DS:DATA

This tells the assembler to use the CODE segment for the code segment register (CS) and the DATA segment for the data segment register (DS).

ORG Directive

The ORG directive sets the starting address for the code or data segment. This is useful when you need to control where certain parts of your program are loaded in memory.

Example:

assembly

ORG 100h
MOV AX, 1234h

This code sets the starting address of the following instructions to 100h.

DB, DW, DD Directives

These directives define initialized data in memory. DB (Define Byte), DW (Define Word), and DD (Define Double Word) are used to allocate memory and initialize it with specified values.

Example:

assembly

DATA SEGMENT
    myByte DB 0FFh         ; Define a byte with value 0FFh
    myWord DW 1234h        ; Define a word with value 1234h
    myDWord DD 12345678h   ; Define a double word with value 12345678h
DATA ENDS

EQU Directive

The EQU directive is used to define constants. It assigns a constant value to a symbol, which can then be used throughout the program.

Example:

assembly

PI EQU 3.14
MOV AX, PI

Here, PI is defined as 3.14 and can be used in place of the constant value.

END Directive

The END directive marks the end of the source code. It is necessary for the assembler to know where the program ends.

Example:

assembly

END START

PROC and ENDP Directives

The PROC directive defines a procedure (or function), and the ENDP directive marks the end of the procedure. Procedures help structure code into reusable blocks.

Example:

assembly

MyProcedure PROC
    ; Procedure code here
    RET
MyProcedure ENDP

PUBLIC and EXTERN Directives

The PUBLIC directive makes a procedure or variable available to other modules, while the EXTERN directive declares an external procedure or variable defined in another module.

Example:

assembly

PUBLIC MyProcedure
EXTERN OtherProcedure:NEAR

Practical Example: Combining Directives

Let’s create a simple program that includes a data segment, code segment, and a procedure to print a string, showcasing the use of these directives.

assembly

; Define data segment
DATA SEGMENT
    message DB 'Hello, World!', '$'
DATA ENDS

; Define stack segment
STACK SEGMENT
    DB 100H DUP(0)
STACK ENDS

; Define code segment
CODE SEGMENT
    ASSUME CS:CODE, DS:DATA

START:
    MOV AX, DATA      ; Initialize data segment register
    MOV DS, AX
    CALL PrintMessage ; Call the procedure to print the message
    MOV AX, 4C00H     ; DOS function to terminate program
    INT 21H           ; Call DOS interrupt to terminate

PrintMessage PROC
    MOV AH, 09H       ; DOS function to print a string
    LEA DX, message   ; Load address of the message
    INT 21H           ; Call DOS interrupt to print
    RET
PrintMessage ENDP

CODE ENDS

END START

In this example, we define a data segment containing a message and a code segment with the main program and a procedure. Various directives like ASSUME, DB, PROC, ENDP, and END are used to structure the program, making it organized, readable, and easy to manage.

Practical examples of how directives are used in programs

Practical Examples of How Directives Are Used in Programs

Assembly language directives are crucial in managing the assembly process and structuring programs. Here are ten practical examples demonstrating the use of different directives in various contexts:

1. Defining Data Segments

Using SEGMENT and ENDS directives to define a data segment.

assembly

DATA SEGMENT
    message DB 'Hello, Assembly!', 0
    number DW 1234
DATA ENDS

This example defines a data segment with a string and a word (16-bit) number.

2. Using the ASSUME Directive

Telling the assembler which segment registers to use for specific segments.

assembly

CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
    MOV AX, DATA
    MOV DS, AX
CODE ENDS

Here, ASSUME instructs the assembler to use DATA for the DS register and CODE for the CS register.

3. Creating a Simple Program with ORG

Setting the starting address for code.

assembly

ORG 100h
MOV AX, 4C00h
INT 21h

This sets the starting address of the program to 100h, which is typical for .COM files in DOS.

4. Initializing Data with DB, DW, DD

Allocating and initializing different data types.

assembly

DATA SEGMENT
    byteVar DB 0FFh         ; Byte
    wordVar DW 1234h        ; Word
    dwordVar DD 12345678h   ; Double word
DATA ENDS

This example shows how to define and initialize byte, word, and double word variables.

5. Using EQU to Define Constants

Creating a named constant for better code readability.

assembly

PI EQU 3.14
MOV AX, PI

Here, PI is defined as a constant with the value 3.14.

6. Defining Procedures with PROC and ENDP

Creating reusable code blocks.

assembly

PrintMessage PROC
    MOV AH, 09h
    LEA DX, message
    INT 21h
    RET
PrintMessage ENDP

This procedure, PrintMessage, prints a string to the screen.

7. Making Variables and Procedures Public with PUBLIC

Allowing other modules to access a procedure or variable.

assembly

PUBLIC PrintMessage
DATA SEGMENT
    message DB 'Hello, World!', '$'
DATA ENDS

The PrintMessage procedure and message variable are made public for use in other modules.

8. Declaring External References with EXTERN

Using variables or procedures defined in other modules.

assembly

EXTERN PrintMessage:NEAR
CODE SEGMENT
START:
    CALL PrintMessage
CODE ENDS

This example declares PrintMessage as an external procedure.

9. Using END to Mark the End of the Program

Signaling the assembler where the program ends.

assembly

END START

END START tells the assembler that START is the entry point and marks the end of the program.

10. Combining Directives in a Full Program

Using multiple directives to create a complete assembly program.

assembly

DATA SEGMENT
    message DB 'Complete Program', '$'
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
    MOV AX, DATA
    MOV DS, AX
    CALL PrintMessage
    MOV AX, 4C00h
    INT 21h

PrintMessage PROC
    MOV AH, 09h
    LEA DX, message
    INT 21h
    RET
PrintMessage ENDP
CODE ENDS

END START

In this comprehensive example, we define a data segment with a message, set up the code segment with ASSUME, move the data segment address into DS, call the PrintMessage procedure, and end the program with an interrupt call. The procedure is defined with PROC and ENDP, ensuring it’s reusable.

These examples illustrate the practical use of various assembly language directives, helping organize and control the assembly process effectively.