Download Java core to Advance and more Lecture notes Java Programming in PDF only on Docsity!
Assembly Language 3-
4345 Assembly Language
Dr. Esam Al_Qaralleh
CE Department
Princess Sumaya University for Technology
Assembly Language
Overview of Assembly Language
Advantages:
Disadvantages:
9 Faster as compared to programs written using high-level languages
9 Efficient memory usage
9 Control down to bit level
× Need to know detail hardware implementation
× Not portable
× Slow to development and difficult to debug
Basic components in assembly Language:
Instruction, Directive, Label, and Comment
Assembly Language 3-
Example of Assembly Language Program
;NUMOFF.ASM: Turn NUM-LOCK indicator off. .MODEL SMALL .STACK .CODE .STARTUP MOV AX,40H ;set AX to 0040H D1: MOV DS,AX ;load data segment with 0040H MOV SI,17H ;load SI with 0017H AND BYTE PTR [SI],0DFH ;clear NUM-LOCK bit .EXIT END
Comments
Assembly directive
Instructions
Assembly directive
Label
Assembly Language 3-
The Big (Simplified) Picture
*char tmpfilename;int num_schedulers=0; int num_request_submitters=0;int i,j; if (!(f = fopen(filename,"r"))) {xbt_assert1(0,"Cannot open file %s",filename); }while(fgets(buffer,256,f)) { if (!strncmp(buffer,"SCHEDULER",9))num_schedulers++; if (!strncmp(buffer,"REQUESTSUBMITTER",16))num_request_submitters++; }fclose(f); tmpfilename = strdup("/tmp/jobsimulator_
High-level code
COMPILER
add $t3, $s0, $t3^ sll $t3,^ $t1,^2 sll $t4, $t0, 2add $t4, $s0, $t lw $t5, 0($t3) lwslt $t2, $t5, $t6 $t6, 0($t4) beq $t2, $zero, endif add $t0, $t1, $zerosll $t4, $t0, 2 add $t4, $s0, $t4lw $t5, 0($t3) lw $t6, 0($t4) slt $t2, $t5, $t6beq $t2, $zero, endif
Assembly code
ASSEMBLER
(^010000101010110110101010101111010101) 101001010101010001 (^101010101010100101111100001010101001) 000101010111101011 (^010000000010000100000010001000100011) (^101001010010101011000101010010010101) 010101010101010101 (^101010101111010101101010101010100101) 111100001010101001
Machine code
ALU^ ControlUnit
Program counter register register register
CPU
Assembly Language 3-
Software Model for the 8086
Overview
Intel 8088 facts
VDD (5V)
GND
CLK
20-bit address 8-bit data
control •• ••• signals To 8088
control signals from 8088
8088 signal classification
¾ 20 bit address bus allow accessing
1 M memory locations
¾ 16-bit internal data bus and 8-bit
external data bus. Thus, it need
two read (or write) operations to
read (or write) a 16-bit datum
¾ Byte addressable and byte-swapping
Memory locations
5A
18000 2F
Low byte of word
High byte of word
Word: 5A2F
Assembly Language 3-
Organization of 8088/
AH AL BH BL CH CL DH DL SP BP SI DI
ALU
Flag register
Execution Unit (EU)
EU control
Σ
CS DS SS ALU Data bus ES (16 bits)
Address bus (20 bits)
Instruction Queue
Bus control External bus
IP
Data bus (16 bits)
Bus Interface Unit (BIU)
General purpose register
Segment register
The 8086 Registers
- To write assembly code for an ISA (Instruction Set
Architecture) you must know the name of registers
- Because registers are places in which you put data to perform
computation and in which you find the result of the computation
(think of them as variables)
- The registers are really numbered, but assembly languages give
them “easy-to-remember” names
- The 8086 offered 16-bit registers
- Four general purpose 16-bit registers
Assembly Language 3-
The 8086 Registers
The 8086 Registers
• Two 16-bit index registers:
– SI
– DI
• These are basically general-purpose registers
• But by convention they are often used as
“pointers”, i.e., they contain addresses
• And they cannot be decomposed into High and
Low 1-byte registers
Assembly Language 3-
The 8086 Registers
• Two 16-bit special registers:
– BP: Base Pointer
– SP: Stack Pointer
– We’ll discuss these Later
• Four 16-bit segment registers:
– CS: Code Segment
– DS: Data Segment
– SS: Stack Segment
– ES: Extra Segment
– We’ll discuss them later as well
The 8086 Registers
• The 16-bit Instruction Pointer (IP) register:
– Points to the next instruction to execute
• The 16-bit FLAGS registers
– Information is stored in individual bits of the FLAGS
register
– Whenever an instruction is executed and produces a
result, it may modify some bit(s) of the FLAGS register
– Example: Z (or ZF) denotes one bit of the FLAGS
register, which is set to 1 if the previously executed
instruction produced 0, or 0 otherwise
Assembly Language 3-
Arithmetic Logic Unit (ALU)
n bits n bits
A B
Y
F
Carry
Y= 0?
A > B?
F Y
0 0 0 A + B
0 0 1 A - B
0 1 0 A - 1
0 1 1 A and B
1 0 0 A or B
1 0 1 not A
¾ Signal F control which function will be conducted by ALU.
¾ Signal F is generated according to the current instruction.
¾ Basic arithmetic operations: addition, subtraction, •••••
¾ Basic logic operations: and, or, xor, shifting, •••••
Flag Register
⎯ OF DF IF TF SF ZF ⎯ AF ⎯ PF ⎯ CF
¾ Control Flags ¾^ Status Flags
IF: Interrupt enable flag DF: Direction flag TF: Trap flag
CF: Carry flag PF: Parity flag AF: Auxiliary carry flag ZF: Zero flag SF: Sign flag OF: Overflow flag
Flag register contains information reflecting the current status of a
microprocessor. It also contains information which controls the
operation of the microprocessor.
Assembly Language 3-
Instruction Machine Codes
Instruction machine codes are binary numbers
¾ For Example:
1 0 0 0 1 0 0 0 1 1 0 0 0 0 1 1 MOV AL, BL
MOV
Machine code structure
Opcode Operand
¾ Opcode tells what operation is to be performed.
(EU control logic generates ALU control signals according to Opcode)
¾ Some instructions do not have operands, or have only one operand
¾ Operands tell what data should be used in the operation. Operands can
be addresses telling where to get data (or where to store results)
Register mode
Mode Operand
¾ Mode indicates the type of a instruction: Register type, or Memory type
EU Operation
ALU Data bus (16 bits)
AH AL BH BL CH CL DH DL SP BP SI DI
General purpose register
ALU
Flag register
EU control instruction 1011000101001010
1. Fetch an instruction from instruction
queue
2. According to the instruction, EU control
logic generates control signals.
( This process is also referred to as instruction
decoding)
3. Depending on the control signal,
EU performs one of the following
operations:
¾ An arithmetic operation ¾ A logic operation ¾ Storing a datum into a register ¾ Moving a datum from a register ¾ Changing flag register
Assembly Language 3-
Memory Segmentation
A segment is a 64KB block of memory starting from any 16-byte
boundary
¾ For example: 00000, 00010, 00020, 20000, 8CE90, and E0840 are all valid
segment addresses
¾ The requirement of starting from 16-byte boundary is due to the 4-bit
left shifting
Segment registers in BIU
CS
SS
DS
ES
Code Segment
Data Segment
Stack Segment
Extra Segment
Memory Address Calculation
Segment addresses must be stored
in segment registers
Offset is derived from the combination
of pointer registers, the Instruction
Pointer (IP), and immediate values
Segment address
Offset
Memory address
Examples
3 4 8 A 0
3 8 A B 4
CS
IP +
Instruction address
F F E 0
5 F F E 0
SS
SP +
Stack address
DS
DI +
Data address
Assembly Language 3-
Fetching Instructions
Where to fetch the next instruction?
CS
IP
12352 MOV AL, 0
8088 Memory
Update IP
— After an instruction is fetched, Register IP is updated as follows:
IP = IP + Length of the fetched instruction
— For Example: the length of MOV AL, 0 is 2 bytes. After fetching this instruction, the IP is updated to 0014
Accessing Data Memory
There is a number of methods to generate the memory address when
accessing data memory. These methods are referred to as
Addressing Modes
Examples:
— Direct addressing: MOV AL, [0300H]
DS
Memory address
(assume DS=1234H)
— Register indirect addressing: MOV AL, [SI]
DS
Memory address
(assume DS=1234H) (assume SI=0310H)
Assembly Language 3-
Address Computation Example
- Consider the whole 1MB address space
- Say that we want a 64K segment whose end is 8K from the end of the
address space
- The address at the end of the address space is FFFFF
- 8K in binary is 1000000000000, that is 01000 in hex
- So the address right after the end of the segment is
FFFFF - 01000 + 1 = FEFFF + 1 = FF
- The length of the segment is 64K
- 64K in binary is 1000000000000000, that is 08000
- So the address at the beginning of the segment is
FF000 - 08000 = F
- So the value to store in a segment register is F
- To reference the 43th byte in the segment, one must store 002A (= 42 10 ) in
an index register
- The address of that byte is: F7000 + 002A = F702A
- The address of the last byte in the segment is: F7000 + 07FFF = FEFFF
- Which is right before FF000, the beginning of the last 8K of the address space
Instructions Format and
Compilation
Assembly Language 3-
;NUMOFF.ASM: Turn NUM-LOCK indicator off.
.MODEL SMALL
.STACK
.CODE
.STARTUP
MOV AX,40H ;set AX to 0040H
MOV DS,AX ;load data segment with 0040H
MOV SI,17H ;load SI with 0017H
AND BYTE PTR [SI],0DFH ;clear NUM-LOCK bit
.EXIT
END
All characters following a “;” till the line end
are “comments”, ignored by the assembler
Assembler reserved words
Assembly language instructions
Developing software for the personal computer
.ASM file
Assembly Language 3-
Developing software for the personal computer
.ASM file
;NUMOFF.ASM: Turn NUM-LOCK indicator off.
.MODEL SMALL
.STACK
.CODE
.STARTUP
MOV AX,40H ;set AX to 0040H
MOV DS,AX ;load data segment with 0040H
MOV SI,17H ;load SI with 0017H
AND BYTE PTR [SI],0DFH ;clear NUM-LOCK bit
.EXIT
END
Register pair (16 bit) (destination of “MOV”)
Hexadecimal value to be loaded (source for “MOV”)
Data Segment register pair Prepare the Data Segment
Source Index
The complete address
of the byte containing
NumLock bit is
specified.
First operand and destination for
logical “AND” Memory address
specified by DS and SI together.
Second operand for logical “AND”
(immediate hexadecimal value)
AND ing with DFH=1101.1111B,
only b5 (bit 5) of specified memory
location is affected (reset to 0)
Assembly Language 3-
DATA SEGMENT PARA 'DATA‘ ORG 7000H POINTS DB 16 DUP(?) SUM DB? DATA ENDS
CODE SEGMENT PARA 'CODE‘ ASSUME CS:CODE, DS:DATA ORG 8000H TOTAL: MOV AX,7000H MOV DS,AX MOV AL, ••••••••• CODE ENDS END TOTAL
0000 DATA SEGMENT PARA 'DATA’ ORG 7000H 7000 0010 [00] POINTS DB 16 DUP(?) 7010 00 SUM DB? 7011 DATA ENDS
0000 CODE SEGMENT PARA 'CODE' ASSUME CS:CODE, DS:DATA ORG 8000H 8000 B8 7000 TOTAL: MOV AX,7000H 8003 8E D8 MOV DS,AX 8005 B0 00 MOV AL, •••••••••
Source File List File
Assembler Directives
Assembler Directives
SEGMENT directive
ENDS directive
END directive
ORG directive
DB: Define Byte; DW, ….
ASSUME directive
— Specifies the segment register (segment Register) that will be used to calculate the effective addresses for all labels and variables defined under a given segment or group name (segment Na
If CS = 1230H and DS = 5678H, what are the physical memory addresses of label TOTAL and variable SUM?
Assembly Language 3-
Assembler Directives
.MODEL SMALL .DATA ORG 7000H POINTS DB 16 DUP(?) SUM DB?
.CODE ORG 8000H TOTAL: MOV AX,7000H MOV DS,AX MOV AL, ••••••••• RET END TOTAL
Simplified Segment Directives Predefined .Mode Types
DATA SEGMENT
CODE SEGMENT TINY one one SMALL one one MEDIUM one multiple COMPACT multiple one LARGE multiple multiple HUGE multiple multiple FLAT* one one
- Flat is used for 32-bit addressing
Build Executable Programs
Syntax check Translate source files into machine code
Source files
Assembler Linker
OBJ files
OBJ files
library
Executable files
Assemblers
Question: What is the difference between *.com and *.exe files? http://www.faqs.org/faqs/msdos-programmer-faq/part2/section-9.html
¾ Microsoft ML, LINK, & DEBUG ¾ 8086 Emulator ¾ A ¾ MASM32 package ¾ •••••••
