Basic Tasm n1p6l

Basic for Assembly Programming Computer Organization and Assembly Language #2

C. Vongchumyen 12 / 2003

Assembly Language Assembly language: Assembly language is used for most programming because it is extremely difficult to program a microprocessor in its native, that is hexadecimal machine language. Assembler: An assembler is a program that converts software written in symbolic machine language (the source programme) into hexadecimal machine language (object programme). The primary reason to use assembler is because development and modification are always difficult in machine language.

s in 80x86 microprocessor General Purpose s • AX Accumulator • BX Base • CX Counting • DX Data 15

8 7

0

AX

AH

AL

Accumulator

BX

BH

BL

Base

CX

CH

CL

Counter

DX

DH

DL

Data

Computer Organization and Assembly Language #2


s in 80x86 microprocessor Segment s • CS Code Segment • DS Data Segment • SS Stack Segment • ES Extra Segment

CS = F000H IP = 1234H Physical Address = F0000 H + 1234 H = F1234 H Computer Organization and Assembly Language #2


s in 80x86 microprocessor

Special • BP Base Pointers • SI Source Index • DI Destiny Index • SP Stack pointer • IP Next Instruction Pointer • F Flag O, D, I, T, S, Z, A, P, C



Flag

11 10

OF DF IF TF SF ZF AF PF CF

Over Flow Direction Interrupt Trap Sign Zero Auxiliary Parity Carry

OF

DF

IF

TF

9

8

7

6

SF

ZF

AF

PF

4

2

0

CF

Over flow from arithmetic Inc or Dec for moving or compare string Enable or Disable all external interrupt Enable or Disable single step operation Sign bit for arithmetic number, 1 = negative Result is zero Carry out for bit 3 on 8-bit data Even or Odd parity of low-order, 8-bit data Carry out from MSB, Left most of arithmetic



Addressing Mode

MOV CX,DX

Immediate

Direct

MOV AL,22h

MOV CX,[1234h]

Indirect MOV AX,[BX] ; SI,DI,BP,BX

Base Plus Index MOV CX,[BX+ DI] ; BP, BX + SI, DI Relative

MOV AX, [BX+1000h]

Base Relative Plus Index

MOV AX,[BX+SI+100h] MOV AX,ARRAY[BX+SI]



Assembly Template Page 60,132 Title Exasm1 skeleton of an assembly Program ; -----------------------------------------------------------STACKSG Segment Para stack 'Stack' STACKSG Ends DATASG DATASG

Segment Para 'Data' Ends

CODESG Begin

Segment Para 'Code' Proc far CS:CODESG, DS:DATASG, SS:STACKSG ax,DATASG ds,ax ... ax,4C00h 21h endp Ends Begin

Assume mov mov mov int Begin CODESG

End



Assembly Template Page 60,132 • 60 Lines per page • 132 Character per line on listing file ( .LST )

Title Exasm1 skeleton of an assembly Program This text will show on every page of listing file

; ------------------------------------------Comment, Start with ; ( Semi colon )



Assembly Template STACKSG Segment Para ……… Defining Stack Segment ………. STACKSG Ends Name Alignment : Para Combine : Stack Class Type : ‘Stack’

stack 'Stack‘

Segment Align Combine ‘class’ = start address in slot of 10H = Combine segment with other when linked = Group related segment when linking



Assembly Template DATASG Segment ……… Defining Data Segment ………. DATASG Ends

Para 'Data‘

CODESG Segment ……… Defining Code Segment ………. CODESG Ends

Para 'Code‘



Assembly Template Begin

Proc Assume mov mov

Begin

far CS:CODESG, DS:DATASG, SS:STACKSG ax,DATASG ds,ax

... endp

Defining Procedure Begin Proc Begin endp Defining Segment Assume

Far

CS:CODESG, DS:DATASG, SS:STACKSG

Set Address of Data Segment mov ax,DATASG mov ds,ax



Assembly Template Set Program Entry Point End Begin

Exit Code mov int

ax,4C00h 21h

• Using Dos Interrupt Function 4CH • Return 00H as exit code to DOS



Assembly Template ( next one ) .Model TINY .STACK .DATA

.CODE ORG 100H mov mov ……… mov int

ax,@data ds,ax ax,4C00h 21h

end Computer Organization and Assembly Language #2


Assembly Template ( next one ) . Model Mode

Code

TINY

Data

Stack

64 KB

Max Total

64 KB

Small

64 KB

64 KB

128 KB

Compact

64 KB

64 KB Each

640 KB

Medium

64 KB Each

64 KB

640 KB

Large

64 KB Each

64 KB Each

640 KB

Huge

64 KB Each

64 KB Each

640 KB



Assembly Template ( next one ) .STACK Defining Stack Area .DATA Defining Data Area .CODE Defining Code Area

End End Program Directive



Assembly Template ( next one )

Set Address of Data segment Mov ax,@data Mov ds,ax ORG 100H First Op-Code locate at Offset 100H ( Required for .COM File )



Assemble and Linking Step of Assembly Programming • Create Source Code • Assemble • Link • Test and Debug Tool For Assembly Programming 1. Text Editor 2. Assembler ( TASM, MASM ) 3. Linker ( TLINK, LINK ) 4. Debugger ( Debug, Turbo Debugger)



Assemble and Linking C:\TASM\BIN>TASM test.asm ; /l = generate listing file Turbo Assembler Version 4.1 Copyright (c) 1988, 1996 Borland International Assembling file: test.asm Error messages: None Warning messages: None es: 1 Remaining memory: 454k

.OBJ

.EXE C:\TASM\BIN>TLINK test Turbo Link Version 5.1 Copyright (c) 1992 Borland International



Frequency Error & Warning .Model TINY .STACK .DATA

.CODE ORG 100H mov mov ……… mov int

ax,@data ds,ax ax,4C00h 21h

**Fatal** test.asm(xx) Unexpected end of file encountered Computer Organization and Assembly Language #2


Frequency Error & Warning .Model TINY .CODE ORG 100H mov mov ……… mov int end

ax,@data ds,ax ax,4C00h 21h Warning: No stack



Basic Instruction

Instruction : MOV Purpose : Data transfer between memory cells, s and the accumulator. Syntax :

MOV Destiny, Source

Example : MOV AX,0006h MOV BX,AX MOV AX,4C00h



Basic Instruction

Instruction : LEA Purpose :

To load the address of the source operator

Syntax :

LEA destiny, source

Example : LEA SI,VAR1 equivalent to: MOV SI,OFFSET VAR1



Basic Instruction

Instruction : LAHF Purpose : It transfers the content of the flags to the AH Syntax :

LAHF

Example :

LAHF

This instruction is useful to the state of the flags during the execution of our program



Basic Instruction

Instruction : POP Purpose : It recovers a piece of information from the stack Syntax :

POP destiny

Example :

POP AX



Basic Instruction

Instruction : POPF Purpose :

It extracts the flags stored on the stack

Syntax :

POPF

Example :

POPF

BIT FLAG 0 CF, 2 PF, 4 AF, 6 ZF, 7 SF, 8 TF, 9 IF, 10 DF, 11 OF



Basic Instruction

Instruction : PUSH Purpose :

It places a word on the stack

Syntax :

PUSH source

Example :

PUSH AX



Basic Instruction Instruction : PUSHF Purpose :

It places the value of the flags on the stack.

Syntax :

PUSHF

Example :

PUSHF

This command decreases by 2 the value of the SP and then the content of the flag is transferred to the stack, on the address indicated by SP. The flags are left stored in memory on the same bits indicated on the POPF command. Computer Organization and Assembly Language #2


Basic Instruction Instruction : AND Purpose : It performs the conjunction of the operators bit by bit. Syntax :

AND destiny, source

Example : AND AX,0FF00H AND AX,BX AND AX,[BX]



Basic Instruction Instruction : NEG Purpose :

It generates the complement to 2.

Syntax :

NEG destiny

Example :

NEG AX

For example, if AX stores the value of 1234H, then: NEG AX This would leave the 0EDCCH value stored on the AX .



Basic Instruction

Instruction : NOT Purpose :

It carries out the negation of the destiny operator bit by bit.

Syntax :

NOT destiny

Example :

NOT AX



Basic Instruction Instruction : OR Purpose :

Logic inclusive OR

Syntax :

OR destiny, source

Example : OR OR

OR AX,0FF00H AX,BX AX,[BX]



Basic Instruction Instruction : XOR Purpose :

Logic exclusive OR

Syntax :

XOR destiny, source

Example : XOR AX,0FF00H XOR AX,BX XOR AX,[BX]



Basic Instruction Instruction : TEST Purpose :

It logically compares the operators

Syntax :

TEST destiny, source

Example : TEST AX,0FF00H TEST AX,BX TEST AX,[BX] It performs a conjunction, bit by bit, of the operators, but differing from AND, this instruction does not place the result on the destiny operator, it only has effect on the state of the flags. Computer Organization and Assembly Language #2


Basic Instruction

Instruction : ADC Purpose :

addition with carry

Syntax :

ADC destiny, source

Example : ADC AX,0FF00H ADC AX,BX ADC AX,[BX]



Basic Instruction

Instruction : ADD Purpose :

addition without carry

Syntax :

ADD destiny, source

Example : ADD AX,0FF00H ADD AX,BX ADD AX,[BX]



Basic Instruction

Instruction : DIV Purpose :

Division without sign.

Syntax :

DIV source

Example :

DIV BL ( 8 Bit ) AL = AX / BL AH = Remainder BX ( 16 Bit ) AX = DX:AX / BX DX = Remainder

DIV



Basic Instruction Instruction : IDIV Purpose :

Division with sign.

Syntax :

IDIV source

Example : IDIV BL ( 8 Bit ) IDIV BX ( 16 Bit ) basically consists on the same as the DIV instruction, and the only difference is that this one performs the operation with sign. For its results it used the same s as the DIV instruction. Computer Organization and Assembly Language #2


Basic Instruction

Instruction : MUL Purpose :

Multiplication without sign.

Syntax :

MUL source

Example :

MUL CH ( 8 Bit ) AX = CH * AL MUL BX ( 16 Bit ) DX:AX = BX * AX



Basic Instruction

Instruction : IMUL Purpose :

Integer Multiplication with sign.

Syntax :

IMUL source

Example :

IMUL CH ( 8 Bit ) AX = CH * AL IMUL BX ( 16 Bit ) DX:AX = BX * AX



Basic Instruction

Instruction : SUB Purpose :

subtraction without carry

Syntax :

SUB destiny, source

Example : SUB SUB

SUB AX,0FF00H AX,BX AX,[BX]



Basic Instruction

Instruction : SBB Purpose :

subtraction without borrow

Syntax :

SBB destiny, source

Example : SBB SBB

SBB AX,0FF00H AX,BX AX,[BX]



Basic Instruction

Instruction : SBB Purpose :

subtraction without borrow

Syntax :

SBB destiny, source

Example : SBB SBB

SBB AX,0FF00H AX,BX AX,[BX]



Basic Tasm n1p6l

Overview 4q3b3c

More details 26j3b

Related Documents 171j1w

Basic Tasm n1p6l

Tasm Programs 2i104d

Tasm 5 Intel 8086 Turbo Assembler 2a6i1a

Tasm For Windows 8 64 Bit - Viralmarch 1v1g2g

Basic 3r4h16

Basic Trojan In Visual Basic 5y5l3u