1. x86, Assembler
TASM, MASM, NASM

2. Available assembler MASM TASM NASM etc, Flat Assembler, SpAssembler
Microsoft : Macro Assembler
TASM
Borland : Turbo Assembler
NASM
Library General Public License (LGPL) [Free] : Netwide Assembler
etc, Flat Assembler, SpAssembler

3. MASM: Microsoft Macro Assembler
MASM contains a macro language with looping, arithmetic, text string processing, and so on, and
MASM supports the instruction sets of the 386, 486, and Pentium processors, providing you with greater direct control over the hardware. You also can avoid extra time and memory overhead when using MASM.
html/vcoriMicrosoftAssemblerMacroLanguage.asp

4. TASM: Turbo Assembler
TASM, Inpise's Borland Turbo Assembler, supports an alternative to MASM emulation. This is known as Ideal mode and provides several advantages over MASM.
The key (questionable) disadvantage, of course, is that MASM style assemblers cannot assemble Ideal mode programs.

5. NASM: Netwide Assembler
NASM is designed for portability and modularity. It supports a range of object file formats including Linux, Microsoft 16-bit OBJ and Win32. Its syntax is designed to be simple and easy to understand, similar to Intel's but less complex.
It supports Pentium, P6, MMX, 3DNow! and SSE opcodes, and has macro capability. It includes a disassemble as well.
NASM is Library General Public License (LGPL) [Free]

6. FASM: Flat Assembler
Currently it supports all /Pentium instructions with MMX, SSE, SSE2, SSE3 and 3DNow! extensions, can produce output in binary, MZ, PE, COFF or ELF format.
It includes the powerful but easy to use macroinstruction support and does multiple passes to optimize the instruction codes for size. The flat assembler is self-compilable and the full source code is included.

7. About developing assembly language
CPU’s language (instructions)
X86 instruction set
About Complier
Directives
MASM
TASM
NASM

8. TASM

9. Important files Compiler Linker TASM 16 bits real mode
TASM32 32 bits protected mode
Linker
TLINK

10. Pseudo instructions Segment, ends : To define a segment.
Assume: To specify which segment defined by “Sengment, ends” should use which segment-register
Data Allocate

11. Segment Declaration Usage Ex. Segment_name segment … Segment_name ends
Cseg segment
Cseg ends

12. Label declaration Usage Ex. Label name follow with colon “:” Start: …
mov bx, offset start …
jmp Start

13. Data allocate Define value Usage DB Define Byte DW Define Word
DD Define Doubleword
DQ Define Quadword
DT Define Ten Bytes
Usage
Var_name Dx data

14. Ex. Data allocation dseg segment dseg ends Msg db “hello world$”
MulH dw 0, 1, 2, 3
MulF dd 1234h
dseg ends

15. Data duplication Usage Ex. type count dup (value) data1 db 10 dup (0)
data2 db 2 dup (3 dup (0))
data3 db 3 dup (1, 2, 3 dup (4))
data4 db 4 dup (?)

16. Structure Struc PosType Row dw ? Col dw ? Ends PosType
Union PosValType
Pos PosType ?
Val dd ?
Ends PosValType
Point PosValType ?

17. Structure mov [Point.Pos.Row], bx ; mov [Point.Pos.Row], bl ;
; OK: Move BX to Row component of Point
mov [Point.Pos.Row], bl ;
; Error: mismatched operands

18. Data reference offset directive, To retrieve an offset of a data
mov bx, offset msg1 ;dx=offset/addr
To retrieve / put a data
mov dx, msg1 ;dx = [msg1]
mov [msg1], dx ;[msg1] = dx
mov [bx+2], dx ;[bx+2] = dx

19. Memory contents ByteVal db ? ;"ByteVal" is name of byte variable
mov ax, bx ;OK: Move value of BX to AX
mov ax, [bx]
;OK: Move word at address BX to AX. Size of
;destination is used to generate proper object code
mov ax,[word bx]
;OK: Same as above with unnecessary size qualifier
mov ax,[word ptr bx]
;and redundant pointer prefix
mov al, [bx]
;OK: Move byte at address BX to AL. Size of
mov [bx], al ; OK: Move AL to location BX

20. Memory contents mov ByteVal, al ;Warning: "ByteVal" needs brackets
;OK: Move AL to memory location named "ByteVal"
mov [ByteVal], ax
;Error: unmatched operands
mov al, [bx+2]
;OK: Move byte from memory location BX+2 to AL
mov al, bx[2]
; Error: indexes must occur with "+" as above
mov bx, Offset ByteVal
;OK: Offset statement does not use brackets
mov bx, Offset [ByteVal]
; Error: offset cannot be taken of the contents of memory

21. Memory contents lea bx, [ByteVal]
;OK: Load effective address of "ByteVal"
lea bx, ByteVal
;Error: brackets required
mov ax, 01234h
;OK: Move constant word to AX
mov [bx], 012h
;Warning: size qualifier needed to determine
;whether to populate byte or word
mov [byte bx], 012h
;OK: constant 012h is moved to byte at address BX
mov [word bx], 012h
;OK: constant 012h is moved to word at address BX

22. Echo entered string cseg segment assume cs:cseg, ds:cseg org 100h
start: jmp load
Buf db 11, 12 dup (' ')
_ent db 10,13,’$’ ;lf,cr
load: mov ah,0ah
mov dx,offset buf
int 21h
mov ah,09h
mov dx,load
mov dx,offset _ent
mov al,[buf+1]
mov ah,00h
mov bx,offset buf+2
add bx,ax
mov byte ptr [bx],'$'
mov ah,09h
mov dx,offset buf+2
int 21h
int 20h
cseg ends
end start

23. Compiling a program Syntax:
TASM [options] source [,object] [,listing] [,xref]
/z Display source line with error message
/zi,/zd,/zn Debug info: zi=full, zd=line numbers only, zn=none Ex
TASM –zi hello.asm

24. Creating an executable file
TLINK objfiles, exefile, mapfile, libfiles, deffile, resfiles
/v Full symbolic debug information
/t Create COM file (same as /Tdc)
/Txx Specify output file type
Tdx DOS image (default)
x can be e=EXE or c=COM
Twx Windows image
x can be e=EXE or d=DLL Ex
Tlink /v /t hello;

25. NASM

26. NASM vs. MASM & TASM NASM is case sensitive.
NASM Requires Square Brackets For Memory References
No need ‘offset’, either ‘equ’ or ‘address’
mov ax, data ; mov ax, offset data
Use square bracket to retrieve content
mov ax, [data] ;
Everything is treated as a label instead of var or equ or else

27. NASM vs. MASM & TASM Does not support hybrid syntaxes, such as
mov ax, table [bx] -> mov ax, [table + ax]
Likewise
mov ax, es:[di] -> mov ax, [es:di]

28. NASM Doesn't Store Variable Types
NASM, by design, chooses not to remember the types of variables you declare. Whereas MASM will remember, on seeing `var dw 0', that you declared `var' as a word-size variable, and will then be able to fill in the ambiguity in the size of the instruction
‘mov var,2’, NASM will deliberately remember nothing about the symbol ‘var’ except where it begins, and so you must explicitly code
‘mov word [var],2’.

29. NASM Doesn't Store Variable Types
For this reason, NASM doesn't support the `LODS', `MOVS', `STOS', `SCAS', `CMPS', `INS', or `OUTS' instructions, but only supports the forms such as `LODSB', `MOVSW', and `SCASD', which explicitly specify the size of the components of the strings being manipulated.

30. NASM Doesn't `ASSUME'
As part of NASM's drive for simplicity, it also does not support the ‘ASSUME’ directive.
NASM will not keep track of what values you choose to put in your segment registers, and will never _automatically_ generate a segment override prefix.

31. NASM Doesn't Support Memory Models
NASM also does not have any directives to support different 16-bit memory models. The programmer has to keep track of which functions are supposed to be called with a far call and which with a near call, and is responsible for putting the correct form of ‘RET’ instruction (`RETN' or `RETF'; NASM accepts `RET' itself as an alternate form for `RETN'); in addition, the programmer is responsible for coding CALL FAR instructions where necessary when calling _external_ functions, and must also keep track of which external variable definitions are far and which are near.

32. Layout of a NASM Source Line
Like most assemblers, each NASM source line contains (unless it is a macro, a preprocessor directive or an assembler directive: some combination of the four fields
label: instruction operands ; comment

33. Declaring Initialized Data
DB, DW, DD, DQ and DT are used, much as in MASM, to declare initialized data in the output file. They can be invoked in a wide range of ways:
db 0x ; just the byte 0x55
db 0x55,0x56,0x57 ; three bytes in succession
db 'a',0x ; character constants are OK
db 'hello',13,10,'$'; so are string constants
dw 0x ; 0x34 0x12
dw 'a' ; 0x61 0x00 (it's just a number)
dw 'ab' ; 0x61 0x62 (character constant)
dw 'abc' ; 0x61 0x62 0x63 0x00 (string)
dd 0x ; 0x78 0x56 0x34 0x12
dd e ; floating-point constant
dq e ; double-precision float
dt e ; extended-precision float

34. Declaring Uninitialized Data
RESB, RESW, RESD, RESQ and REST are designed to be used in the BSS section of a module: they declare uninitialized storage space.
Each takes a single operand, which is the number of bytes, words, doublewords or whatever to reserve.
NASM does not support the MASM/TASM syntax of reserving uninitialized space by writing `DW ?' or similar things.

35. Defining Constants
EQU defines a symbol to a given constant value: when EQU is used, the source line must contain a label. The action of EQU is to define the given label name to the value of its (only) operand.
This definition is absolute, and cannot change later. So, for example,
message db 'hello, world'
msglen equ $-message

36. Repeating Instructions or Data
The TIMES prefix causes the instruction to be assembled multiple times. This is partly present as NASM's equivalent of the DUP syntax supported by MASM-compatible assemblers, in that you can code
zerobuf: times 64 db 0
times 100 movsb ; trivial unrolled loops

37. Effective Addresses
An effective address is any operand to an instruction which references memory. Effective addresses, in NASM, have a very simple syntax: they consist of an expression evaluating to the desired address, enclosed in square brackets. For example:
wordvar dw
mov ax,[wordvar]
mov ax,[wordvar+1]
mov ax,[es:wordvar+bx]

38. Numeric Constants
A numeric constant is simply a number. NASM allows you to specify numbers in a variety of number bases, in a variety of ways: you can suffix
H, Q or O, and B for hex, octal and binary, or
prefix ‘0x’ or ‘$’ for hex in the style of C and Pascal
Note, a hex number prefixed with a ‘$’ sign must have a digit after the ‘$’ rather than a letter.

39. Ex. Numeric Constants mov ax,100 ; decimal mov ax,0a2h ; hex
mov ax,$0a ; hex again
; the 0 is required
mov ax,0xa ; hex yet again
mov ax,777q ; octal
mov ax,777o ; octal again
mov ax, b ; binary

40. Echo entered string org 0x100 start:jmp load buf: db 11 resb 12
;reserve 12 bytes
_ent: db 10, 13, '$‘
load: mov ah,0ah
mov dx,buf
int 21h
mov ah,$09
mov dx,_ent
mov al,[buf+1]
mov ah,0x00
mov bx,buf+2
add bx,ax
mov byte [bx],'$'
mov ah,09h
mov dx,buf+2
int 21h
int 20h

41. How to NASM… nasm -f bin program.asm -o program.com
nasm -f bin driver.asm -odriver.sys

42. Q & A
That’s it for now.