1 / 46

# COS2014 Assembly Language Fundamentals - PowerPoint PPT Presentation

COS2014 Assembly Language Fundamentals. Assembly Language for Intel-Based Computers, 5 th Edition. Kip Irvine. Chapter Overview. Basic Elements of Assembly Language Example: Adding and Subtracting Integers Assembling, Linking, and Running Programs Defining Data Symbolic Constants

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about ' COS2014 Assembly Language Fundamentals' - gotzon

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

### Assembly Language for Intel-Based Computers, 5th Edition

Kip Irvine

• Basic Elements of Assembly Language

• Example: Adding and Subtracting Integers

• Assembling, Linking, and Running Programs

• Defining Data

• Symbolic Constants

Include file

Code section

Starting with an Example

; Adds and subtracts three 32-bit integers

; (10000h + 40000h + 20000h)

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

• Basic Elements of Assembly Language

• Integer constants and expressions

• Character and string constants

• Reserved words and identifiers

• Directives and instructions

• Labels

• Mnemonics and Operands

• Example: Adding and Subtracting Integers

• Assembling, Linking, and Running Programs

• Defining Data

• Symbolic Constants

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

Reserved Words, Directives

; (10000h + …

INCLUDE Irvine32.inc

.code

main PROC

mov eax,10000h

sub eax,20000h

call DumpRegs

exit

main ENDP

END main

• 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

begin with semicolon (;)

begin with COMMENT directive and a programmer-chosen character, end with the same character, e.g.

COMMENT !

Comment line 1

Comment line 2

!

; (10000h + …

INCLUDE Irvine32.inc

.code

main PROC

mov eax,10000h

sub eax,20000h

call DumpRegs

exit

main ENDP

END main

Copies necessary definitions and setup information from a text file named Irvine32.inc, located in the assembler’s INCLUDE directory (see Chapt 5)

Include Files

; (10000h + …

INCLUDE Irvine32.inc

.code

main PROC

mov eax,10000h

sub eax,20000h

call DumpRegs

exit

main ENDP

END main

Marks the beginning of the code segment, where all executable statements in a program are located

Code Segment

; (10000h + …

INCLUDE Irvine32.inc

.code

main PROC

mov eax,10000h

sub eax,20000h

call DumpRegs

exit

main ENDP

END main

[label] PROC

[label] ENDP

Label:

Place markers: marks the address (offset) of code and data

Assigned a numeric address by assembler

Data label: must be unique, e.g. myArray

Code label: target of jump and loop instructions, e.g. L1:

Procedure Definition

; (10000h + …

INCLUDE Irvine32.inc

.code

main PROC

mov eax,10000h

sub eax,20000h

call DumpRegs

exit

main ENDP

END main

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 \$

Identifiers

; (10000h + …

INCLUDE Irvine32.inc

.code

main PROC

mov eax,10000h

sub eax,20000h

call DumpRegs

exit

main ENDP

END main

• Optional leading + or – sign

• Binary, decimal, hexadecimal, or octal digits

• d – decimal

• b – binary

• r – encoded real

• Examples: 30d, 6Ah, 42, 1101b

• Hexadecimal beginning with letter: 0A5h

Instruction mnemonics:

help to memorize

examples: MOV, ADD, SUB, MUL, INC, DEC

Operands:

constant

constant expression

register

memory (data label, register)

Instructions

; (10000h + …

INCLUDE Irvine32.inc

.code

main PROC

mov eax,10000h

sub eax,20000h

call DumpRegs

exit

main ENDP

END main

Destination

operand

Source

operand

immediate values

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

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

I/O

; (10000h + …

INCLUDE Irvine32.inc

.code

main PROC

mov eax,10000h

sub eax,20000h

call DumpRegs

exit

main ENDP

END main

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

Remaining

; (10000h + …

INCLUDE Irvine32.inc

.code

main PROC

mov eax,10000h

sub eax,20000h

call DumpRegs

exit

main ENDP

END main

• Program output, showing registers and flags

EAX=00030000 EBX=7FFDF000 ECX=00000101 EDX=FFFFFFFF

ESI=00000000 EDI=00000000 EBP=0012FFF0 ESP=0012FFC4

EIP=00401024 EFL=00000206 CF=0 SF=0 ZF=0 OF=0

; 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

• .386 directive:

• 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

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

END main

• Basic Elements of Assembly Language

• Example: Adding and Subtracting Integers

• Assembling, Linking, and Running Programs

• Defining Data

• Symbolic Constants

• Steps from creating a source program through executing the compiled program

http://kipirvine.com/asm/gettingStarted/index.htm

• MASM 6.15 (with all examples of textbook)

• 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

• make32 xxx (where xxx is your file name)

• 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 …

• Use it to see how your program is compiled

• Contains

• source code

• object code (machine language)

• segment names

• symbols (variables, procedures, and constants)

00000000 .code

00000000 main PROC

00000000 B8 00010000 mov eax,10000h

0000000A 2D 00020000 sub eax,20000h

0000000F E8 00000000E call DumpRegs

exit

00000014 6A 00 * push +000000000h

00000016 E8 00000000E * call ExitProcess

0000001B main ENDP

END main

memorycontent

• 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

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

REAL10 80-bit (10-byte) IEEE extended real

• 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 ?

• 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

• 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,00100010b

list4 BYTE 0Ah,20h,‘A’,22h

• 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

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

"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?

• 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

• Define storage for 16-bit integers

• or double characters

• single value or multiple values

word1 WORD 65535 ; 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

• Storage definitions for 32-bit integers, quadwords, tenbyte values, and real numbers:

val1 DWORD 12345678h ; unsigned

val2 SDWORD –2147483648 ; signed

val3 DWORD 20 DUP(?) ; unsigned array

val4 SDWORD –3,–2,–1,0,1 ; signed array

val1 TBYTE 1000000000123456789Ah

rVal1 REAL4 -2.1

rVal2 REAL8 3.2E-260

rVal3 REAL10 4.6E+4096

ShortArray REAL4 20 DUP(0.0)

• ; 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

• sub eax,val3 ; subtract 20000h

• mov finalVal,eax ; store the result (30000h)

• call DumpRegs ; display the registers

• exit

• main ENDP

• END main

00000000 .data

00000000 00010000 val1 DWORD 10000h

00000004 00040000 val2 DWORD 40000h

00000008 00020000 val3 DWORD 20000h

0000000C 00000000 finalVal DWORD ?

00000000 .code

00000000 main PROC

0000000B 2B 05 00000008 R sub eax,val3 ; subtract 20000h

00000011 A3 0000000C R mov finalVal,eax; store result

00000016 E8 00000000 E call DumpRegs ; display registers

exit

00000022 main ENDP

main()

{

int val1=10000h;

int val2=40000h;

int val3=20000h;

int finalVal;

finalVal = val1

+ val2 - val3;

}

• .data

• val1 DWORD 10000h

• val2 DWORD 40000h

• val3 DWORD 20000h

• finalVal DWORD ?

• .code

• main PROC

• mov eax,val1

• sub eax,val3

• mov finalVal,eax

• call DumpRegs

• exit

• main ENDP

• 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

• 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

• 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

• 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

• 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"

• Basic Elements of Assembly Language

• Example: Adding and Subtracting Integers

• Assembling, Linking, and Running Programs

• Defining Data

• Symbolic Constants

• 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