Transcript Lecture #6
Thursday, January 21
Program
Due
#1 is posted
Friday, June 9th
Quiz #2
Thursday, July 15th
Today’s topics
Assembly language program development
Introduction to MASM
Assembler, Linker, IDE
http://kipirvine.com/asm/gettingStarted
Install Visual C++ 2008 Express Edition
(if you don’t already have a version of
Visual C++)
Install the Microsoft Assembler
Install the libraries
We will use Irvine's library (for now) to
handle the really awful stuff.
input / output, screen control, timing, etc.
Additional resources
Course website “Resources”
MASM Guide
MASM instruction set
Template for all programs
Demo programs
Etc.
Program development
Design
Implement
Test / Debug
Use and maintain
Development tools
Editor
Assembler
Libraries
Linker
Loader
Operating system
Program
design and
algorithms
Binary
Executable
code
(.exe file)
Text editor
Text
source
code
(.asm file)
Binary
machine
code
(.obj file)
Library
files
(.inc, .lib)
Linker
Loader
Binary
program in
memory
Assembler
Instruction
Execution
Cycle
(Operating
System)
execution
begins
MASM instruction types
Move data
Arithmetic
Compare two values
Conditional/unconditional branch
Call procedure
Loop control
I/O
Instruction formats
Variable length
Opcode
Fixed length
Operand specification
different “addressing modes” for different opcodes
different number of operands for different opcodes
opcode
opcode
destination
opcode
destination, source
Addressing modes
Immediate
Direct
Register
Register indirect
Set register to a constant
“array” element, using offset in register
Indexed
Base-indexed
Stack
Memory area specified and maintained
as a stack; stack pointer in register
Offset (branch)
“goto” address; may be computed
Set register to address of global
Use register as operand
Access memory through address in a
register
Start address in one register; offset in
another, add and access memory
MASM data types
Type
BYTE
Used for:
Strings, 1-byte unsigned integers [0 … 255]
SBYTE
1-byte signed integers [-128 … 127]
WORD
2-byte unsigned integers [0 … 65535], address
SWORD
2-byte signed integers [-32768 … 32767]
DWORD
4-byte unsigned integers [0 … 4294967295], address
SDWORD 4-byte signed integers [-2147483648 … 2147483647]
FWORD
6-byte integer
QWORD
8-byte integer
TBYTE
10-byte integer
REAL4
4-byte floating-point
Memory locations
May be named
Name can refer to a variable name or a
program label
Interpretation of contents depends on
program instructions
Numeric data
Non-numeric data
Integer, floating point
Character, string
Instruction
Address
etc.
General form of a MASM statement
Comments start with ;
Segments start with .
Each instruction line has 4 fields:
Label
Opcode
Operands
Comment
Depending on the opcode, one or more
operands may be required
Otherwise, any field may be empty
If empty opcode field, operand field must be empty
TITLE Program Template
(template.asm)
; Author:
; Course/project ID
; Description:
Date:
; (include any libraries here)
; (insert symbol definitions here)
.data
; (insert variables here)
.code
main PROC
; (insert executable instructions here)
exit
main ENDP
; exit to operating system
; (insert additional procedures here)
Getting started
We will use Irvine's library (for now) to handle
the really awful stuff.
input / output
screen control
timing
etc.
Check the Resources page, MASM
Example program development walk-through
MASM program
TITLE directive
you can put anything you want
… but the grader wants to see a meaningful
title and the name of the source code file
; identification block
technically optional (as are all comments)
… but the grader wants to see information
(see template.asm)
INCLUDE directive
copies a file of definitions and procedures into
the source code
use Irvine32.inc for now
MASM program
Global constants may be defined
.data directive
marks beginning of data segment
variable declarations go here
.code directive
marks end of data segment and beginning of
code segment
main procedure defined here (required)
other procedures defined here (optional)
Data definition
in the .data segment
General form is
label
initializer(s)
;comment
label is the "variable name"
data_type is one of (see previous slide)
at least one initializer is required
data_type
may be ?
(value to be assigned later)
Examples:
size
DWORD
temperature
response BYTE
gpa
REAL4
myName
BYTE
100
;class size
SWORD -10
;current Celsius
'Y'
;positive answer
?
;my GPA
”Wile E. Coyote”,0
main procedure
in the .code segment
General form is
main
PROC
; (program instructions)
main
ENDP
; (other procedures)
END
main
Identifiers
1 to 247 characters (no spaces)
NOT case sensitive!
Start with letter, _ , @, or $
For now, don’t use _ , @ , or $
Remaining characters are letters, digits, or _
Identify variables, constants, procedures,
and labels
Cannot be a reserved word
Literals
Actual values, named constants
Assign contents of registers, memory
Initialize variables in the .data segment
Integer
Floating point
Character
String
Integer
Optional radix: b, q/o, d, h
Literals
Digits must be consistent with radix
Hex values that start with a letter must have leading 0
Default (no radix) is decimal
Floating-point (real)
Optional sign
Standard notation
(e.g., -3.5 +5.
Exponent notation (e.g., -3.5E2
Must have decimal point
7.2345)
6.15E-3)
Character
Literals
Single character in quotes
’a’ ”*”
Single quotes recommended
String
Characters in quotes
’always’,0
”123 * 654”,0
Double quotes recommended
Embedded quotes must be different
”It’s”,0
’Title: ”MASM”’,0
Strings must be null-terminated
Always end with zero-byte
Directives
Tell the assembler how to interpret the
code
Mark beginning of program segments
.data
.code
Mark special labels
main
proc
Instructions
For now, know how to use
mov
add
sub
mul, imul
div, idiv
inc
dec
loop
Some instructions use implied operands
See Irvine (Appendix B) or on-line Instructions
Easy Instructions
mov
add
sub
inc
dec
op1, op2
op1, op2
op1, op2
op
op
;op2 is copied to op1
;op2 is added to op1
;op2 is subtracted from op1
; add 1 to op
; subtract 1 from op
For 2-operand instructions the first operand is the
destination and the second operand is the source
2-operand instructions require at least one of the
operands to be a register (or op2 must be literal).
Note: op1 can not be a literal ! (Why?)
Instructions with implied operands
mul, imul implied operand must be in eax
mul op2
; result is in EDX:EAX
Example:
mov
mov
mul
eax,10
ebx,0Ch
ebx
; result is in eax (120),
;
with possible
;
overflow in edx
Instructions with implied operands
div, idiv implied operand is in EDX:EAX
so set edx to 0 before division
div op2
; quotient is in EAX
; remainder is in EDX
Example:
mov
mov
mov
div
eax,100
edx,0
ebx,9
ebx
; quotient is in eax (11)
; remainder is in edx (1)
Instructions with implied operands
loop
implied operand is ecx
so set ecx to the loop count, and put a label
at the beginning of the loop
mov
ecx,10
repeat:
; loop body
;…
loop
repeat
ecx is automatically decremented by 1 and tested each
time the loop statement is executed. When ecx
becomes 0, the loop terminates.
Library Procedures - Overview p1
See IrvineLibHelp.exe at
http://classes.engr.oregonstate.edu/eecs/winter2010/cs271/resources/Links.htm/
Clrscr : Clear the screen
Preconditions: none
Postconditions: screen cleared and cursor is at upper
left corner
Crlf : New line
Preconditions: none
Postconditions: cursor is at beginning of next new line
Library Procedures - Overview p2
ReadInt : Reads a 32-bit signed decimal integer
from keyboard, terminated by the Enter key.
Preconditions: none
Postconditions: value entered is in EAX
ReadString : Reads a string from keyboard,
terminated by the Enter key.
Preconditions: OFFSET of memory destination in EDX
Size of memory destination in ECX
Postconditions: String entered is in memory
Length of string entered is in EAX
Library Procedures - Overview p3
WriteDec : Writes an unsigned 32-bit integer to
the screen in decimal format.
WriteInt - Writes a signed 32-bit integer to the
screen in decimal format.
Preconditions: value in EAX
Postconditions: value displayed
Preconditions: value in EAX
Postconditions: value displayed
WriteString - Writes a null-terminated string to
the screen.
Preconditions: OFFSET of memory location in EDX
Postconditions: string displayed
Calling a Library Procedure
• Call a library procedure using the CALL instruction.
• Some procedures require input arguments.
• The INCLUDE directive copies the procedure
prototypes (declarations) into the program source
code.
• Example: display "1234" on the console:
INCLUDE Irvine32.inc
...
mov eax,1234 ; input argument
call WriteDec ; show number
call Crlf ; end of line
Calling a Library Procedure
• Sometimes certain registers are used to pass
parameters
• Sometimes values of registers must be saved (in
memory) before calling a procedure, and restored
to the original values when control returns.
INCLUDE Irvine32.inc
...
mov saveA,eax ;save the eax register
mov eax,-123 ;value to display
call WriteInt ;show number
call Crlf ;end of line
mov eax,saveA ;restore eax
In-line Comments
Start with ;
May be on separate line or at end of a line
Use comments to clarify lines or sections
Preferred …
; Calculate the number of students in class today.
mov
eax,size
sub
eax,absent
mov
present,eax
OK …
mov
sub
mov
eax,size
eax,absent
present,eax
;start with class size
;subtract absentees
;number present
eax,size
eax,absent
present,eax
;move size into eax
;subtract absent from eax
;move eax to present
Terrible …
mov
sub
mov
Program Design
Decide what the program should do
Define algorithm(s)
Decide what the output should show
Determine what variables/constants are
required
Implementing a MASM program
Open project
Start with template
Fill in header information
Define constants
Test*/fix (no calculations, usually everything shows 0)
Enter the input code
Test*/fix (syntax check, nothing happens)
Enter the output code
Test*/fix (syntax check, nothing happens)
Declare variables (.data section)
Save as program name (.asm)
Test*/fix (no calculations, echo input)
Enter the calculation code
Test*/fix (logic check, verify)
* First try Debug, Start Without Debugging
Questions?
Program #1
due Friday, July 9th, before midnight
Quiz #2
Thursday, July 15th
Read Irvine Chapter 4