1. Hardware & Software Architecture
Week 7 & 8
Hardware & Software Architecture

2. Basic Instruction Set
The x86 instruction set is extremely huge, but we usually don't need to use them all. Here are some simple instructions you should know to get you started:
Instruction
Description
ADD
Adds the two operands and stores the result into the first operand.
SUB
Subtracts the second operand from the first and stores the result in the first operand.
MUL
Multiplies the operand with the Accumulator Register and stores the result in the Accumulator Register.
DIV
Divides the Accumulator Register by the operand and stores the result in the Accumulator Register.
AND
Performs the bitwise logical AND operation on the operands and stores the result in the first operand. OR
Performs the bitwise logical OR operation on the operands and stores the result in the first operand.
INC
Increases the value of the operand by 1 and stores the result in the operand.
DEC
Decreases the value of the operand by 1 and stores the result in the operand.

3. Basic Instruction Set …
Description
NEG
Negates the operand and stores the result in the operand.
PUSH
Pushes the value of the operand on to the top of the stack.
POP
Pops the value of the top item of the stack in to the operand.
MOV
Stores the second operand's value in the first operand.
CMP
Subtracts the second operand from the first operand and sets the respective flags.
JMP
Jumps to label.
INT constant
Calls the interrupt specified by the operand.

4. Basic instructions… mov eax,10000h add eax,40000h sub eax,20000h
The MOV instruction moves (copies) the integer 10000h to the EAX register. The first operand (EAX) is called the destination operand, and the second operand is called the source operand.
add eax,40000h
The ADD instruction adds 40000h to the EAX register.
sub eax,20000h
The SUB instruction subtracts 20000h from the EAX register.

5. Moving Data into Registers
The first thing we will want to learn about programming at the level of the CPU, is how to put data into registers. For this we use the MOV instruction.
code fragment which moves the number 47 into the EDX register:
>> MOV EDX, 47
The following code moves the hexadecimal number A4C9 into the 16 bit AX register:
>> MOV AX, 0A4C9h
Similarly, if we wished to move the binary number into the 8 bit BH register we would type the following code:
>> MOV BH, b

6. 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

7. Meanings of the Code
Assembly code Machine code MOV EAX, 10000h B (Move 10000h into EAX) ADD EAX, 40000h (Add 40000h to EAX) SUB EAX, 20000h 2D (SUB 20000h from EAX)
Operand in instruction 6

8. Fetched MOV EAX, 10000h Register Memory ALU B8 00010000 EAX EBX data…
EBX
data B8 00 01
MOV EAX, 10000h 00 00 05 00
ALU 04
ADD EAX, 40000h 00 00
SUB EAX, 20000h IR PC B …
address 7

9. Execute MOV EAX, 10000h Register Memory ALU B8 00010000 EAX 00010000…
EBX
data B8 00 01
MOV EAX, 10000h 00 00 05 00
ALU 04
ADD EAX, 40000h 00 00
SUB EAX, 20000h IR PC B …
address 8

10. Fetched ADD EAX, 40000h Register Memory ALU 05 00040000 EAX 00010000…
EBX
data B8 00 01
MOV EAX, 10000h 00 00 05 00
ALU 04
ADD EAX, 40000h 00 00
SUB EAX, 20000h IR PC …
address 9

11. Execute ADD EAX, 40000h Register Memory ALU 05 00040000 EAX 00050000…
EBX
data B8 00 01
MOV EAX, 10000h 00 00 05 00
ALU 04
ADD EAX, 40000h 00 00
SUB EAX, 20000h IR PC …
address 10

12. 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

13. Reserved Words, Directives
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
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

14. 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

15. Comments Single-line comments Multi-line comments 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
Single-line comments
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 !

16. Include Files INCLUDE directive: 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
INCLUDE directive:
Copies necessary definitions and setup information from a text file named Irvine32.inc, located in the assembler’s INCLUDE directory (see Chapt 5)

17. Code Segment .code directive: 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
.code directive:
Marks the beginning of the code segment, where all executable statements in a program are located

18. Procedure Definition 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
Procedure defined by:
[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:

19. 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 $

20. Instructions Destination operand Source operand immediate values
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
[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)
Destination
operand
Source
operand
immediate values

21. 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.

22. 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

23. 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

24. 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

25. 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

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

27. 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 abc (where abc is your file name)
When assembled, just write abc to run the code.

28. 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 …

29. 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

30. 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

31. 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

32. 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 ?

33. 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

34. Defining Byte Arrays list1 BYTE 10,20,30,40 list2 BYTE 10,20,30,40
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

35. Defining Strings An array of characters str1 BYTE "Enter your name",0
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 at Tabuk University.",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

36. 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"

37. 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

38. 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

39. 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