0. COS2014 Assembly Language Fundamentals

1. Assembly Language for Intel-Based Computers, 5th Edition
Kip Irvine

2. Chapter Overview Basic Elements of Assembly Language
Example: Adding and Subtracting Integers
Assembling, Linking, and Running Programs
Defining Data
Symbolic Constants
Real-Address Mode Programming

3. Starting with an Example
TITLE Add and Subtract (AddSub.asm)
; Adds and subtracts three 32-bit integers
; (10000h h h)
INCLUDE Irvine32.inc
.code
main PROC
mov eax,10000h ; EAX = 10000h
add eax,40000h ; EAX = 50000h
sub eax,20000h ; EAX = 30000h
call DumpRegs ; display registers
exit
main ENDP
END main
Title/header
Include file
Code section

4. Chapter Overview Basic Elements of Assembly Language
Integer constants and expressions
Character and string constants
Reserved words and identifiers
Directives and instructions
Labels
Mnemonics and Operands
Comments
Example: Adding and Subtracting Integers
Assembling, Linking, and Running Programs
Defining Data
Symbolic Constants
Real-Address Mode Programming

5. Reserved Words, Directives
TITLE:
Define program listing title
Reserved word of directive
Reserved words
Instruction mnemonics, directives, type attributes, operators, predefined symbols
See MASM reference in Appendix A
Directives:
Commands for assembler
TITLE Add and …
; Adds and subtracts
; (10000h + …
INCLUDE Irvine32.inc
.code
main PROC
mov eax,10000h
add eax,40000h
sub eax,20000h
call DumpRegs
exit
main ENDP
END main

6. Directive vs Instruction
Directives: tell assembler what to do
Commands that are recognized and acted upon by the assembler, e.g. declare code, data areas, select memory model, declare procedures, etc.
Not part of the Intel instruction set
Different assemblers have different directives
Instructions: tell CPU what to do
Assembled into machine code by assembler
Executed at runtime by the CPU
Member of the Intel IA-32 instruction set
Format: LABEL (option), Mnemonic, Operands, Comment

7. Comments Single-line comments Multi-line comments TITLE Add and …
begin with semicolon (;)
Multi-line comments
begin with COMMENT directive and a programmer-chosen character, end with the same character, e.g.
COMMENT !
Comment line 1
Comment line 2 !
TITLE Add and …
; Adds and subtracts
; (10000h + …
INCLUDE Irvine32.inc
.code
main PROC
mov eax,10000h
add eax,40000h
sub eax,20000h
call DumpRegs
exit
main ENDP
END main

8. Include Files INCLUDE directive: TITLE Add and …
Copies necessary definitions and setup information from a text file named Irvine32.inc, located in the assembler’s INCLUDE directory (see Chapt 5)
TITLE Add and …
; Adds and subtracts
; (10000h + …
INCLUDE Irvine32.inc
.code
main PROC
mov eax,10000h
add eax,40000h
sub eax,20000h
call DumpRegs
exit
main ENDP
END main

9. Code Segment .code directive: TITLE Add and …
Marks the beginning of the code segment, where all executable statements in a program are located
TITLE Add and …
; Adds and subtracts
; (10000h + …
INCLUDE Irvine32.inc
.code
main PROC
mov eax,10000h
add eax,40000h
sub eax,20000h
call DumpRegs
exit
main ENDP
END main

10. Procedure Definition Procedure defined by: TITLE Add and …
[label] PROC
[label] ENDP
Label:
Place markers: marks the address (offset) of code and data
Assigned a numeric address by assembler
Follow identifier rules
Data label: must be unique, e.g. myArray
Code label: target of jump and loop instructions, e.g. L1:
TITLE Add and …
; Adds and subtracts
; (10000h + …
INCLUDE Irvine32.inc
.code
main PROC
mov eax,10000h
add eax,40000h
sub eax,20000h
call DumpRegs
exit
main ENDP
END main

11. Identifiers Identifiers: TITLE Add and …
; Adds and subtracts
; (10000h + …
INCLUDE Irvine32.inc
.code
main PROC
mov eax,10000h
add eax,40000h
sub eax,20000h
call DumpRegs
exit
main ENDP
END main
Identifiers:
A programmer-chosen name to identify a variable, a constant, a procedure, or a code label
1-247 characters, including digits
not case sensitive
first character must be a letter, ?, or $

12. Integer Constants Optional leading + or – sign
Binary, decimal, hexadecimal, or octal digits
Common radix characters:
h – hexadecimal
d – decimal
b – binary
r – encoded real
Examples: 30d, 6Ah, 42, 1101b
Hexadecimal beginning with letter: 0A5h

13. Instructions Destination operand Source operand immediate values
[label:] mnemonic operand(s) [;comment]
Instruction mnemonics:
help to memorize
examples: MOV, ADD, SUB, MUL, INC, DEC
Operands:
constant
constant expression
register
memory (data label, register)
TITLE Add and …
; Adds and subtracts
; (10000h + …
INCLUDE Irvine32.inc
.code
main PROC
mov eax,10000h
add eax,40000h
sub eax,20000h
call DumpRegs
exit
main ENDP
END main
Destination
operand
Source
operand
immediate values

14. Instruction Format Examples
No operands
stc ; set Carry flag
nop ; no operation
One operand
inc eax ; register
inc myByte ; memory
Two operands
add ebx,ecx ; register, register
sub myByte,25 ; memory, constant
add eax,36 * 25 ; register, constant-expr.

15. I/O Not easy, if program by ourselves Two steps: call DumpRegs:
TITLE Add and …
; Adds and subtracts
; (10000h + …
INCLUDE Irvine32.inc
.code
main PROC
mov eax,10000h
add eax,40000h
sub eax,20000h
call DumpRegs
exit
main ENDP
END main
Not easy, if program by ourselves
Will use the library provided by the author
Two steps:
Include the library (Irvine32.inc) in your code
Call the subroutines
call DumpRegs:
Calls the procedure to displays current values of processor registers

16. Remaining exit: END main: TITLE Add and … ; Adds and subtracts
; (10000h + …
INCLUDE Irvine32.inc
.code
main PROC
mov eax,10000h
add eax,40000h
sub eax,20000h
call DumpRegs
exit
main ENDP
END main
exit:
Halts the program
Not a MSAM keyword, but a command defined in Irvine32.inc
END main:
Marks the last line of the program to be assembled
Identifies the name of the program’s startup procedure

17. Example Program Output
Program output, showing registers and flags
EAX= EBX=7FFDF000 ECX= EDX=FFFFFFFF
ESI= EDI= EBP=0012FFF0 ESP=0012FFC4
EIP= EFL= CF=0 SF=0 ZF=0 OF=0

18. Alternative Version of AddSub
TITLE Add and Subtract (AddSubAlt.asm)
; adds and subtracts 32-bit integers
.386
.MODEL flat,stdcall
.STACK 4096
ExitProcess PROTO, dwExitCode:DWORD
DumpRegs PROTO
.code
main PROC
mov eax,10000h ; EAX = 10000h
add eax,40000h ; EAX = 50000h
sub eax,20000h ; EAX = 30000h
call DumpRegs
INVOKE ExitProcess,0
main ENDP
END main

19. Explanations .386 directive: .MODEL directive: PROTO directives:
Minimum processor required for this code
.MODEL directive:
Generate code for protected mode program
Stdcall: enable calling of Windows functions
PROTO directives:
Prototypes for procedures
ExitProcess: Windows function to halt process
INVOKE directive:
Calls a procedure or function
Calls ExitProcess and passes it with a return code of zero

20. Suggested Program Template
TITLE Program Template (Template.asm)
; Program Description:
; Author:
; Creation Date:
; Revisions:
; Date: Modified by:
INCLUDE Irvine32.inc
.data
; (insert variables here)
.code
main PROC
; (insert executable instructions here)
exit
main ENDP
; (insert additional procedures here)
END main

21. What's Next Basic Elements of Assembly Language
Example: Adding and Subtracting Integers
Assembling, Linking, and Running Programs
Defining Data
Symbolic Constants
Real-Address Mode Programming

22. Assemble-Link-Execute Cycle
Steps from creating a source program through executing the compiled program

23. Download, Install, and Run
MASM 6.15 (with all examples of textbook)
Masm615.zip: download from the course web site
Unzip the archive and run setup.exe
Choose the installation directory
Suggest using the default directory
See index.htm in the archive for details
Go to C:\Masm615 (if installed default)
Write assembly source code
TextPad, NotePad++, UltraEdit or …
make32 xxx (where xxx is your file name)

24. Suggestion Study make32.bat and make16.bat
To know where assembling stage and linking stage are
Think about linking with other language (ex: C or C++ or …)
Understand that MASM is only one of the assemblers, and there are still many other assemblers to use
Try to use NASM or TASM
Try to use high‐level compiler to generate assembly codes
gcc or visual c++ or turbo c or …

25. Listing File Use it to see how your program is compiled Contains
source code
addresses
object code (machine language)
segment names
symbols (variables, procedures, and constants)
Example: addSub.lst

26. Listing File 00000000 .code 00000000 main PROC
B mov eax,10000h
add eax,40000h
A 2D sub eax,20000h
F E E call DumpRegs
exit
A * push h
E E * call ExitProcess
B main ENDP
END main
memory content
address

27. What's Next Basic Elements of Assembly Language
Example: Adding and Subtracting Integers
Assembling, Linking, and Running Programs
Defining Data
Intrinsic Data Types
Data Definition Statement
Defining BYTE, SBYTE, WORD, SWORD, DWORD, SDWORD, QWORD, TBYTE
Defining Real Number Data
Little Endian Order
Symbolic Constants
Real-Address Mode Programming

28. Intrinsic Data Types BYTE 8-bit unsigned integer
SBYTE 8-bit signed integer
WORD 16-bit unsigned integer
SWORD 16-bit signed integer
DWORD 32-bit unsigned integer
SDWORD 32-bit signed integer
FWORD 48-bit integer (Far pointer in protected mode)
QWORD 64-bit integer
TBYTE 80-bit (10-byte) integer
REAL4 32-bit (4-byte) IEEE short real
REAL8 64-bit (8-byte) IEEE long real
REAL bit (10-byte) IEEE extended real

29. Data Definition Statement
A data definition statement sets aside storage in memory for a variable
May optionally assign a name (label) to the data
Syntax:
[name] directive initializer [,initializer] . . .
value1 BYTE 10
All initializers become binary data in memory
Use ? if no initialization necessary
Example: Var1 BYTE ?

30. Defining BYTE and SBYTE Data
Each of following defines a single byte of storage:
value1 BYTE 'A' ; character constant
value2 BYTE 0 ; smallest unsigned byte
value3 BYTE 255 ; largest unsigned byte
value4 SBYTE -128 ; smallest signed byte
value5 SBYTE +127 ; largest signed byte
value6 BYTE ? ; uninitialized byte
MASM does not prevent you from initializing a BYTE with a negative value, but it is considered poor style
If you declare a SBYTE variable, the Microsoft debugger will automatically display its value in decimal with a leading sign

31. Defining Byte Arrays Examples that use multiple initializers:
list1 BYTE 10,20,30,40
list2 BYTE 10,20,30,40
BYTE 50,60,70,80
BYTE 81,82,83,84
list3 BYTE ?,32,41h, b
list4 BYTE 0Ah,20h,‘A’,22h

32. Defining Strings An array of characters
Usually enclosed in quotation marks
Will often be null-terminated
To continue a single string across multiple lines, end each line with a comma
str1 BYTE "Enter your name",0
str2 BYTE 'Error: halting program',0
str3 BYTE 'A','E','I','O','U'
greeting BYTE "Welcome to the Encryption Demo program "
BYTE "created by Kip Irvine.",0
menu BYTE "Checking Account",0dh,0ah,0dh,0ah,
"1. Create a new account",0dh,0ah,
"2. Open an existing account",0dh,0ah,
"Choice> ",0
End-of-line sequence:
0Dh = carriage return
0Ah = line feed
Is str1 an array?

33. Using the DUP Operator
Use DUP to allocate (create space for) an array or string
Syntax: counter DUP (argument)
Counter and argument must be constants or constant expressions
var1 BYTE 20 DUP(0) ; 20 bytes, all equal to zero
var2 BYTE 20 DUP(?) ; 20 bytes, uninitialized
var3 BYTE 4 DUP("STACK"); 20 bytes, ; "STACKSTACKSTACKSTACK"
var4 BYTE 10,3 DUP(0),20 ; 5 bytes

34. Defining WORD and SWORD
Define storage for 16-bit integers
or double characters
single value or multiple values
word1 WORD ; largest unsigned value
word2 SWORD –32768 ; smallest signed value
word3 WORD ? ; uninitialized, unsigned
word4 WORD "AB" ; double characters
myList WORD 1,2,3,4,5 ; array of words
array WORD 5 DUP(?) ; uninitialized array

35. Defining Other Types of Data
Storage definitions for 32-bit integers, quadwords, tenbyte values, and real numbers:
val1 DWORD h ; unsigned
val2 SDWORD – ; signed
val3 DWORD 20 DUP(?) ; unsigned array
val4 SDWORD –3,–2,–1,0,1 ; signed array
quad1 QWORD h
val1 TBYTE Ah
rVal1 REAL
rVal2 REAL8 3.2E-260
rVal3 REAL10 4.6E+4096
ShortArray REAL4 20 DUP(0.0)

36. Adding Variables to AddSub
TITLE Add and Subtract, Version (AddSub2.asm)
; This program adds and subtracts 32-bit unsigned
; integers and stores the sum in a variable.
INCLUDE Irvine32.inc
.data
val1 DWORD 10000h
val2 DWORD 40000h
val3 DWORD 20000h
finalVal DWORD ?
.code
main PROC
mov eax,val1 ; start with 10000h
add eax,val2 ; add 40000h
sub eax,val3 ; subtract 20000h
mov finalVal,eax ; store the result (30000h)
call DumpRegs ; display the registers
exit
main ENDP
END main

37. Listing File 00000000 .data 00000000 00010000 val1 DWORD 10000h
C finalVal DWORD ?
code
main PROC
A R mov eax,val1 ; start with 10000h
R add eax,val2 ; add 40000h
B 2B R sub eax,val3 ; subtract 20000h
A C R mov finalVal,eax; store result
E E call DumpRegs ; display registers
exit
main ENDP

38. C vs Assembly main() .data { val1 DWORD 10000h int val1=10000h;
int finalVal;
finalVal = val1
+ val2 - val3; }
.data
val1 DWORD 10000h
val2 DWORD 40000h
val3 DWORD 20000h
finalVal DWORD ?
.code
main PROC
mov eax,val1
add eax,val2
sub eax,val3
mov finalVal,eax
call DumpRegs
exit
main ENDP

39. What's Next Basic Elements of Assembly Language
Example: Adding and Subtracting Integers
Assembling, Linking, and Running Programs
Defining Data
Symbolic Constants
Equal-Sign Directive
Calculating the Sizes of Arrays and Strings
EQU Directive
TEXTEQU Directive
Real-Address Mode Programming

40. Equal-Sign Directive name = expression
expression is a 32-bit integer (expression or constant)
may be redefined
name is called a symbolic constant
Also OK to use EQU
good programming style to use symbols
COUNT = 500 …
mov al,COUNT

41. Calculating the Size of Arrays
Current location counter: $
Size of a byte array
Subtract address of list and difference is the number of bytes
Size of a word array
Divide total number of bytes by 2 (size of a word)
list BYTE 10,20,30,40
ListSize = ($ - list)
list WORD 1000h,2000h,3000h,4000h
ListSize = ($ - list) / 2

42. EQU Directive Define a symbol as either an integer or text expression
Cannot be redefined
OK to use expressions in EQU:
Matrix1 EQU 10 * 10
Matrix1 EQU <10 * 10>
No expression evaluation if within < >
EQU accepts texts too
PI EQU <3.1416>
pressKey EQU <"Press any key to continue",0>
.data
prompt BYTE pressKey

43. TEXTEQU Directive
Define a symbol as either an integer or text expression
Called a text macro
Can be redefined
continueMsg TEXTEQU <"Do you wish to continue (Y/N)?">
rowSize = 5
.data
prompt1 BYTE continueMsg
count TEXTEQU %(rowSize * 2) ; evaluates expression
setupAL TEXTEQU <mov al,count>
.code
setupAL ; generates: "mov al,10"

44. What's Next Basic Elements of Assembly Language
Example: Adding and Subtracting Integers
Assembling, Linking, and Running Programs
Defining Data
Symbolic Constants
Real-Address Mode Programming (skipped)

45. Summary Integer expression, character constant
Directive – interpreted by the assembler
Instruction – executes at runtime
Code, data, and stack segments
Source, listing, object, map, executable files
Data definition directives:
BYTE, SBYTE, WORD, SWORD, DWORD, SDWORD, QWORD, TBYTE, REAL4, REAL8, and REAL10
DUP operator, location counter ($)
Symbolic constant
EQU and TEXTEQU