Tony's CodeForge Blog

Chapter 1: Getting Started with TASM

•

devtony

Overview of Assembly Language

Assembly language is a low-level programming language that offers direct communication with a computer’s hardware. It is crucial in system programming because it allows developers to write programs that are highly efficient and fine-tuned to the underlying hardware. Unlike high-level languages, which abstract away hardware details, assembly language provides precise control over system resources, making it ideal for tasks that require optimal performance and efficiency.

Introduction to Assembly Language and Its Importance in System Programming

Assembly language programming involves writing instructions that a CPU can execute directly. Each instruction corresponds to a basic operation such as moving data between registers, performing arithmetic, or controlling program flow. This level of control is essential for system programming, which includes writing operating systems, device drivers, and other software that interacts closely with hardware.

One of the primary reasons assembly language is important in system programming is its ability to optimize performance. High-level languages often introduce overhead due to their abstraction layers, which can be detrimental in performance-critical applications. In contrast, assembly language allows developers to write code that runs as fast as possible by minimizing this overhead. This is particularly important in environments with limited resources, such as embedded systems, where efficient use of memory and processing power is crucial.

Additionally, assembly language is indispensable for understanding how high-level code translates to machine instructions. This knowledge is vital for debugging and optimizing software, as it helps developers identify performance bottlenecks and implement more efficient algorithms. By mastering assembly language, programmers gain a deeper understanding of how computers work, which can enhance their ability to write high-quality, efficient software.

Installation of TASM

To begin using Turbo Assembler (TASM), you first need to install it on your system. The installation process varies slightly depending on the operating system you’re using. On DOS or Windows, you can typically install TASM by running the setup executable provided by Borland. This setup will guide you through the installation process, including selecting the installation directory and configuring environment variables.

After installation, you need to configure your development environment. This involves setting up the paths to the TASM executable and other tools like Turbo Linker (TLINK). Proper configuration ensures that you can compile and link your assembly programs without encountering path-related issues.

Writing Your First Program

Once TASM is installed and configured, you’re ready to write your first assembly language program. A simple “Hello, World!” program is a great starting point. This program introduces you to the basic structure of an assembly language program and the syntax used in TASM.

Start by creating a new text file with a .ASM extension. Open this file in a text editor and write the following code:

assembly

.model small
.stack 100h
.data
msg db 'Hello, World!', 0

.code
main proc
    mov ax, @data
    mov ds, ax

    lea dx, msg
    mov ah, 09h
    int 21h

    mov ah, 4Ch
    int 21h
main endp
end main

This code defines a simple program that prints “Hello, World!” to the screen. The .model small directive specifies the memory model, while .stack 100h sets up a stack segment. The .data section declares a data segment where the message string is stored, and the .code section contains the actual code that will be executed.

To compile and run this program, open a command prompt, navigate to the directory containing your .ASM file, and use the following commands:

shell

tasm hello.asm
tlink hello.obj
hello.exe

The tasm command assembles the source file into an object file, tlink links the object file into an executable, and running hello.exe executes the program, displaying the message on the screen.

By following these steps, you gain a foundational understanding of how to write, assemble, and run assembly language programs using TASM. This process forms the basis for more advanced assembly language programming, where you’ll explore deeper concepts and techniques to harness the full power of low-level programming.

Comparison Between High-Level and Low-Level Programming Languages

High-level programming languages, such as Python, Java, and C++, are designed to be user-friendly and abstract the complexity of the underlying hardware. They offer features like garbage collection, dynamic typing, and extensive libraries that simplify the development process. However, this abstraction comes at a cost. The layers of abstraction can introduce inefficiencies, making high-level languages less suitable for performance-critical applications.

In contrast, low-level programming languages, like assembly language, provide minimal abstraction from the hardware. Each instruction in an assembly language program corresponds directly to a machine code instruction executed by the CPU. This close relationship allows for fine-tuned performance optimizations but requires the programmer to handle memory management, register allocation, and other low-level details manually.

For example, in a high-level language, sorting an array might be as simple as calling a built-in sort function. The underlying implementation of this function is hidden from the programmer, who trusts that it will work efficiently. In assembly language, sorting an array involves writing explicit instructions for comparing and swapping elements, managing loops, and optimizing the use of CPU registers and memory. This approach offers unmatched control and efficiency but at the cost of increased complexity and development time.

Installation of TASM

Installing Turbo Assembler (TASM) is the first step to diving into assembly language programming. Depending on your operating system, the installation process might differ slightly. On DOS or Windows, you typically start by running the setup executable provided by Borland. This setup will guide you through selecting the installation directory and configuring the necessary environment variables.

Once installed, you need to configure your development environment to recognize the TASM executable and other tools like Turbo Linker (TLINK). Proper configuration ensures that you can compile and link your assembly programs without encountering path-related issues.

Writing Your First Program

With TASM installed and configured, you can begin writing your first assembly language program. A simple “Hello, World!” program is an excellent starting point to familiarize yourself with the basic structure and syntax of an assembly language program in TASM.

Start by creating a new text file with a .ASM extension. Open this file in a text editor and write the following code:

assembly

.model small
.stack 100h
.data
msg db 'Hello, World!', 0

.code
main proc
    mov ax, @data
    mov ds, ax

    lea dx, msg
    mov ah, 09h
    int 21h

    mov ah, 4Ch
    int 21h
main endp
end main

This program defines a simple structure where the .model small directive specifies the memory model, and .stack 100h sets up a stack segment. The .data section declares a data segment where the message string is stored, and the .code section contains the executable instructions.

To compile and run this program, open a command prompt, navigate to the directory containing your .ASM file, and use the following commands:

shell

tasm hello.asm
tlink hello.obj
hello.exe

The tasm command assembles the source file into an object file, tlink links the object file into an executable, and running hello.exe executes the program, displaying the message on the screen.

By understanding the differences between high-level and low-level programming languages and getting hands-on with TASM, you lay a solid foundation for more advanced assembly language programming. This chapter equips you with the basic skills to start exploring the depths of system programming, where efficiency and control are paramount.

Step-by-Step Guide to Installing TASM on Different Operating Systems

Installing TASM on DOS or Windows

First, you need to obtain TASM by downloading the installation files from a reliable source. These files usually come in a compressed format like a ZIP file. After downloading, extract the files to a directory of your choice using a file extraction tool such as WinRAR or 7-Zip.

Once extracted, open the Command Prompt by pressing Win + R, typing cmd, and pressing Enter. Navigate to the directory where you extracted the TASM files using the cd command. For example, if you extracted TASM to C:\TASM, you would type cd C:\TASM and press Enter. If there is a setup executable in the extracted files, run it by typing its name and pressing Enter, and follow any on-screen instructions to complete the installation.

Next, you need to configure the environment variables. Right-click on ‘This PC’ or ‘Computer’ on the desktop or in File Explorer, select ‘Properties’, then ‘Advanced system settings’, and click ‘Environment Variables’. In the ‘System variables’ section, find and select the Path variable, then click ‘Edit’. Add the directory where TASM is installed to the Path variable, which allows you to run TASM commands from any command prompt window. For example, add ;C:\path\to\TASM to the end of the Path variable.

To test the installation, open a new Command Prompt window to ensure the environment variables are updated. Type tasm and press Enter. If the installation was successful, you should see TASM’s help or version information.

Installing TASM on Windows using DOSBox

First, download DOSBox from the official DOSBox website and install it by running the downloaded installer and following the on-screen instructions. Create a directory on your system where you will place the TASM files, for example, C:\TASM. Extract the TASM files to this directory.

Run DOSBox from the Start menu or desktop shortcut. In the DOSBox window, mount the TASM directory by typing mount c c:\tasm and press Enter. Change to the newly mounted directory by typing c: and pressing Enter.

To test TASM in DOSBox, type tasm and press Enter. If configured correctly, you should see TASM’s help or version information.

Installing TASM on macOS or Linux using DOSBox

Install DOSBox using a package manager. For macOS, use Homebrew by typing brew install dosbox in the terminal. For Linux, use your distribution’s package manager, such as APT for Debian-based systems, by typing sudo apt-get install dosbox.

Create a directory on your system where you will place the TASM files, for example, ~/TASM, and extract the TASM files to this directory. Run DOSBox by typing dosbox in your terminal. In the DOSBox window, mount the TASM directory by typing mount c ~/tasm and press Enter. Change to the newly mounted directory by typing c: and pressing Enter.

To test TASM in DOSBox, type tasm and press Enter. If configured correctly, you should see TASM’s help or version information.

By following these steps, you will have successfully installed TASM on your operating system, configured the necessary environment, and ensured it is ready for use. This setup process is essential for beginning your journey into assembly language programming with TASM.

Configuring the development environment.

Configuring the development environment for TASM involves several key steps to ensure a seamless programming experience. After installing TASM, the next phase is to set up the necessary directories and environment variables. Begin by choosing a dedicated directory for your assembly projects. This can be within the same directory where TASM is installed or in a separate location for better organization. Create subdirectories within this main directory to categorize different projects, making it easier to manage your code.

Once the directories are set, you need to configure your system’s environment variables to include the path to the TASM executable. This allows you to run TASM commands from any command prompt or terminal window. On Windows, right-click on ‘This PC’ or ‘Computer’, select ‘Properties’, then ‘Advanced system settings’, and click on ‘Environment Variables’. In the ‘System variables’ section, find and select the Path variable, then click ‘Edit’. Add the path to the directory where TASM is installed. For example, if TASM is installed in C:\TASM, you would add ;C:\TASM to the Path variable.

After configuring the environment variables, verify the setup by opening a new Command Prompt window and typing tasm. If the installation and configuration are correct, TASM’s help or version information will be displayed. This confirms that the TASM executable is recognized by the system and can be accessed from any location.

Next, set up an integrated development environment (IDE) or a text editor for writing and editing your assembly code. While TASM does not come with an IDE, you can use text editors like Notepad++, Sublime Text, or Visual Studio Code, which support syntax highlighting for assembly language. Configure these editors to recognize assembly language files by setting the appropriate file extensions, such as .asm, and enabling syntax highlighting for assembly language.

For DOSBox users, particularly on non-Windows systems like macOS or Linux, the configuration involves mounting the TASM directory and setting up autoexec files to streamline the process. Create a directory for your TASM projects, and within DOSBox, mount this directory by typing commands such as mount c ~/tasm and then switching to the C drive with c:. You can automate this process by editing the DOSBox configuration file to include these commands, ensuring that DOSBox mounts the directory and switches to it automatically upon startup.

Additionally, familiarize yourself with essential command-line tools and batch files to automate repetitive tasks. Writing batch scripts to assemble, link, and execute your assembly programs can save time and reduce errors. For instance, a simple batch file can be created to automate the compilation process: it can run TASM to assemble the code, TLINK to link the object files, and finally execute the resulting executable.

By carefully configuring the development environment, setting up directories, adjusting environment variables, selecting a suitable text editor, and leveraging command-line tools, you create an efficient and productive workspace for developing assembly language programs with TASM. This preparation ensures you can focus on coding and debugging without unnecessary interruptions, facilitating a smoother learning and development process.

Writing Your First Program

Structure of an assembly language program.

Writing your first program in TASM is an exciting step that begins with understanding the structure of an assembly language program. Assembly language programs consist of various segments that define different parts of the code, such as data, code, and stack. These segments are essential for organizing the program and ensuring that it runs correctly.

The structure of an assembly language program typically starts with a data segment, where variables and constants are declared. This is followed by a code segment, which contains the executable instructions, and sometimes a stack segment for temporary data storage during execution. Each segment serves a specific purpose and follows a defined syntax.

Here is a basic structure of an assembly language program in TASM:

assembly

.model small
.stack 100h

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

.code
main proc
    mov ax, @data
    mov ds, ax

    lea dx, message
    mov ah, 09h
    int 21h

    mov ax, 4C00h
    int 21h
main endp

end main

Let’s break down this program to understand its structure:

  1. .model small: This directive tells the assembler that the program will use the small memory model, where code and data are in the same segment.
  2. .stack 100h: This defines the stack segment and allocates 256 bytes (100h in hexadecimal) for the stack.
  3. .data: The data segment begins here, where variables are declared. In this example, a string message is defined with the value “Hello, World!$”.
  4. .code: The code segment starts here, containing the actual instructions to be executed.
  5. main proc: This defines the main procedure of the program. Procedures in assembly language are similar to functions in high-level languages.
  6. mov ax, @data and mov ds, ax: These instructions initialize the data segment register (DS) to point to the data segment, which is necessary for accessing the data defined in the .data segment.
  7. lea dx, message: This instruction loads the effective address of the message into the DX register.
  8. mov ah, 09h and int 21h: These instructions call a DOS interrupt (int 21h) to display the string pointed to by DX. The value 09h in AH specifies the “display string” function of the interrupt.
  9. mov ax, 4C00h and int 21h: These instructions terminate the program and return control to the operating system. The value 4C00h in AX specifies the “terminate program” function of the DOS interrupt.

Writing your first assembly language program involves understanding these basic components and how they interact. The data segment is used for storing variables, the code segment contains the instructions to be executed, and the stack segment manages temporary data during execution.

To assemble and run this program in TASM, follow these steps:

  1. Save the code in a file with an .asm extension, for example, hello.asm.
  2. Open a command prompt or DOSBox and navigate to the directory where the file is saved.
  3. Assemble the program using TASM by typing tasm hello.asm. This command generates an object file (hello.obj).
  4. Link the object file using TLINK by typing tlink hello.obj. This creates an executable file (hello.exe).
  5. Run the executable by typing hello in the command prompt.

By understanding the structure of an assembly language program and following these steps, you can successfully write, assemble, and run your first program in TASM. This foundational knowledge will help you build more complex programs as you become more familiar with assembly language programming.

let’s expand on the example and provide more details to help you better understand writing assembly language programs in TASM. We will go through a few more basic examples to demonstrate different concepts and functionalities.

Example 1: Simple Arithmetic Operations

This program demonstrates basic arithmetic operations like addition and subtraction.

assembly

.model small
.stack 100h

.data
    num1 dw 10
    num2 dw 5
    result dw ?

.code
main proc
    mov ax, @data
    mov ds, ax

    ; Addition: result = num1 + num2
    mov ax, num1
    add ax, num2
    mov result, ax

    ; Display result of addition (simulated by storing in memory)
    ; Subtraction: result = num1 - num2
    mov ax, num1
    sub ax, num2
    mov result, ax

    ; Display result of subtraction (simulated by storing in memory)
    mov ax, 4C00h
    int 21h
main endp

end main

In this program:

  • num1 and num2 are defined in the data segment with initial values.
  • The results of the addition and subtraction are stored in the result variable.
  • The program performs the arithmetic operations and stores the results in memory.

Example 2: Loop and Conditional Statements

This example introduces loops and conditional statements by calculating the factorial of a number.

assembly

.model small
.stack 100h

.data
    num dw 5
    factorial dw 1

.code
main proc
    mov ax, @data
    mov ds, ax

    mov cx, num ; Initialize counter to num
    mov ax, 1   ; Initialize AX to 1

factorial_loop:
    mul cx      ; AX = AX * CX
    loop factorial_loop

    mov factorial, ax

    mov ax, 4C00h
    int 21h
main endp

end main

In this program:

  • The num variable stores the number for which we want to calculate the factorial.
  • The program uses a loop (factorial_loop) to multiply the current value of AX by the counter (CX) until the counter reaches zero.
  • The result is stored in the factorial variable.

Example 3: String Operations

This example demonstrates simple string operations like copying and reversing a string.

assembly

.model small
.stack 100h

.data
    source db 'Hello, World!$', 0
    dest db 20 dup('$')

.code
main proc
    mov ax, @data
    mov ds, ax
    mov es, ax

    lea si, source ; Load address of source string
    lea di, dest   ; Load address of destination string

copy_loop:
    lodsb          ; Load byte from source to AL
    stosb          ; Store byte from AL to destination
    cmp al, '$'    ; Check for end of string
    jne copy_loop  ; If not end, repeat loop

    ; Reverse string (simple approach for demonstration)
    lea si, dest   ; Load address of destination string
    mov cx, 0
find_end:
    lodsb
    cmp al, '$'
    je reverse
    inc cx
    jmp find_end

reverse:
    dec cx
    mov di, si
    sub di, cx
reverse_loop:
    lodsb
    stosb
    loop reverse_loop

    mov ax, 4C00h
    int 21h
main endp

end main

In this program:

  • The source string is copied to the dest string using a loop.
  • The program then reverses the copied string by finding the end of the string and reversing it in place.

Example 4: Input and Output

This example demonstrates how to take input from the user and display output.

assembly

.model small
.stack 100h

.data
    buffer db 20 dup('$')

.code
main proc
    mov ax, @data
    mov ds, ax

    ; Display prompt
    lea dx, prompt
    mov ah, 09h
    int 21h

    ; Read input from user
    lea dx, buffer
    mov ah, 0Ah
    int 21h

    ; Display input
    lea dx, buffer
    mov ah, 09h
    int 21h

    mov ax, 4C00h
    int 21h
main endp

end main

prompt db 'Enter text: $'

In this program:

  • A prompt is displayed to the user using a DOS interrupt.
  • The program then reads input from the user into the buffer.
  • The entered text is displayed back to the user.

These examples demonstrate various fundamental concepts in assembly language programming using TASM, such as arithmetic operations, loops, conditional statements, string operations, and input/output. Each example builds on the basic structure of an assembly language program and introduces new instructions and techniques, providing a comprehensive foundation for learning assembly language.

Creating and Compiling a Simple “Hello, World!” Program Using TASM

To create and compile a simple “Hello, World!” program using TASM, you start by writing the assembly code. Open your text editor and write the following assembly code, then save the file with a .asm extension, for example, helloworld.asm:

assembly

.model small
.stack 100h

.data
    message db 'Hello, World!', '$'

.code
main proc
    mov ax, @data
    mov ds, ax

    lea dx, message ; Load address of message
    mov ah, 09h     ; DOS interrupt for printing string
    int 21h         ; Call DOS interrupt

    mov ax, 4C00h   ; Terminate program
    int 21h         ; Call DOS interrupt
main endp

end main

To compile the assembly code using TASM, open your command prompt and navigate to the directory where your helloworld.asm file is saved. Run the following commands:

First, assemble the program by executing tasm helloworld.asm. This command creates an object file (helloworld.obj). Next, link the object file to create an executable by running tlink helloworld.obj. This command creates an executable file (helloworld.exe).

After compiling the program, you can run the executable by typing helloworld in the command prompt. You should see the message “Hello, World!” displayed on the screen.

Detailed Explanation of the Code

The assembly code begins with .model small, specifying the memory model. The “small” model means that both code and data will fit within a single 64KB segment. The .stack 100h line defines a stack segment with a size of 256 bytes (100h in hexadecimal).

The .data section starts the data segment. The line message db 'Hello, World!', '$' defines a string variable message with the value “Hello, World!” terminated by a dollar sign ($). The dollar sign is used by DOS to identify the end of a string.

In the .code section, the line main proc marks the beginning of the main procedure. The mov ax, @data instruction loads the address of the data segment into the AX register. Following this, mov ds, ax moves the address in AX into the DS (Data Segment) register, setting up the data segment.

The lea dx, message instruction loads the address of the message string into the DX register. The mov ah, 09h instruction moves the value 09h into the AH register, indicating the DOS function for printing a string. The int 21h instruction calls DOS interrupt 21h, which performs the function specified in AH (printing the string pointed to by DX).

To terminate the program, the mov ax, 4C00h instruction moves the value 4C00h into the AX register, indicating the DOS function for terminating a program. The int 21h instruction then calls DOS interrupt 21h to perform the termination.

The main endp line marks the end of the main procedure, and the end main line marks the end of the program, specifying the entry point (main procedure).

This simple “Hello, World!” program demonstrates the basic structure of an assembly language program using TASM, including data declaration, segment setup, DOS interrupt calls for output, and program termination. By following these steps, you can create, compile, and run a basic assembly language program, laying the foundation for more complex programming tasks.

•

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *