Assembly language Constants

There are many directives provided by NASM that define constants. Here, will particularly discuss three directives

1. EQU
2. %assign
3. %define

The EQU Directive

The EQU directive is used for defining constants. The syntax of the EQU directive is as follows −

CONSTANT_NAME EQU expression

For example,

TOTAL_STUDENTS equ 50

You can then use this constant value in your code, like −

mov ecx, TOTAL_STUDENTS
cmp eax, TOTAL_STUDENTS

The operand of an EQU statement can be an expression −

LENGTH equ 20 WIDTH 
equ 10 AREA
equ length * width

Above code segment would define AREA as 200.

Example

SYS_EXIT  equ 1
SYS_WRITE equ 4
STDIN     equ 0
STDOUT    equ 1
section	 .text
   global _start    ;must be declared for using gcc
  
_start:             ;tell linker entry point
   mov eax, SYS_WRITE         
   mov ebx, STDOUT         
   mov ecx, msg1         
   mov edx, len1 
   int 0x80                
  
   mov eax, SYS_WRITE         
   mov ebx, STDOUT         
   mov ecx, msg2         
   mov edx, len2 
   int 0x80 
  
   mov eax, SYS_WRITE         
   mov ebx, STDOUT         
   mov ecx, msg3         
   mov edx, len3 
   int 0x80
   
   mov eax,SYS_EXIT    ;system call number (sys_exit)
   int 0x80            ;call kernel

section	 .data
msg1 db	'Hello Learners!',0xA,0xD 	
len1 equ $ - msg1			

msg2 db 'Welcome to the world of,', 0xA,0xD 
len2 equ $ - msg2 

msg3 db 'Draftsbook assembly programming language ! '
len3 equ $- msg3

OUTPUT

Hello, Learners!
Welcome to the world of,
Draftsbook assembly programming language !

The %assign Directive

The %assign directive can be used to define numeric constants such as the EQU directive which is allows redefinition. For instance, define the constant TOTAL as:

%assign TOTAL 10

Later in the code, you can redefine it as −

%assign TOTAL 20

This directive is case-sensitive.

The %define Directive

The %define directive can defining both numeric and string constants which is more like to the #define in C. For instance, you may define the constant PTR as:

%define PTR [EBP+4]

The above code replaces PTR by [EBP+4].

This directive also provide redefinition and it is case-sensitive.

Assembly language  Variables

In the generated code or data assembly language, every instance of the variable has a fixed value. The type of a variable cannot be changed. Variables are one of the following types:

1. Numeric.
2. Logical.
3. String.

The range of possible values of a numeric variable is the same as the range of possible values of a numeric constant or numeric expression.

Allocating Storage to Initialized Data

The syntax for storage allocation statement for initialized data is −

[variable-name]    define-directive    initial-value   [,initial-value]

Where, variable-name is the identifier for each storage space. The assembler associates an offset value for each variable name defined in the data segment.

The five basic forms of the define directive below in table:

Following are some examples of using define directives:

big_number	DQ	123456789
real_number1	DD	1.234
choice          DB       'y' 
number          DW      12345 
neg_number      DW     -12345
real_number2	DQ	123.456

Some important point need to know:

1. Each byte of character is stored as its ASCII value in hexadecimal.
2. Each decimal value is automatically converted to its 16-bit binary equivalent and stored as a hexadecimal number.
3. Processor uses the little-endian byte ordering.
4. Negative numbers are converted to its 2’s complement representation.
5. Short and long floating-point numbers are represented using 32 or 64 bits, respectively.

Example

section .text
   global _start          ;must be declared for linker (gcc)
  
_start:                   ;tell linker entry point
   mov	edx,1		  ;message length
   mov	ecx,choice        ;message to write
   mov	ebx,1		  ;file descriptor (stdout)
   mov	eax,4		  ;system call number (sys_write)
   int	0x80		  ;call kernel

   mov	eax,1		  ;system call number (sys_exit)
   int	0x80		  ;call kernel

section .data
choice DB 'j'

OUTPUT

j

Allocating Storage Space to Uninitialized Data

The rest of directives are used for reserving space for uninitialized data. The reserve directives take a single operand that specifies the number of units of space to be reserved. Each define directive has a related reserve directive.

There are five basic forms of the reserve directive −

Multiple Definitions

Multiple data definition statements in a program is given below.

choice	   DB 	'Y' 		 ;ASCII of y = 79H
number1	   DW 	12345 	         ;12345D = 3039H
number2    DD  12345679          ;123456789D = 75BCD15H

In the assembler allocates contiguous memory for multiple variable definitions.

Multiple Initializations

The TIMES directive provides multiple initializations to the same value. For instance, an array named marks of size 9 can be defined and initialized to zero using the following statement:

marks  TIMES  9  DW  0

The TIMES directive is useful in defining arrays and tables. Example code below:

section	.text
   global _start        ;must be declared for linker (ld)
  
_start:                 ;tell linker entry point
   mov	edx,5		;message length
   mov	ecx, stars	;message to write
   mov	ebx,1		;file descriptor (stdout)
   mov	eax,4		;system call number (sys_write)
   int	0x80		;call kernel

   mov	eax,1		;system call number (sys_exit)
   int	0x80		;call kernel

section	.data
stars   times 5 db '*'

OUTPUT

*****