1. bahan kuliah: http://www.cs.ui.ac.id/kuliah/POK/
IKI10230 Pengantar Organisasi Komputer Kuliah no. 04: Assembly Language
Sumber: 1. Paul Carter, PC Assembly Language 2. Hamacher. Computer Organization, ed-5 3. Materi kuliah CS61C/2000 & CS152/1997, UCB 4. Intel Architecture Software Developer’s Manual
3 Maret 2004
L. Yohanes Stefanus Bobby Nazief
bahan kuliah:

2. Revisi Jadwal Kuliah TGL NO TOPIK PC Hm 11-Feb 1
Pendahuluan, Organisasi Komputer
18-Feb 2
Stored Program Computers
2.1, 2.2, 2.3, 2.4
25-Feb 3
Tools, Sistem Bilangan, Operasi +, -
1.1
6.1
03-Mar 4
Assembly Language
1.3
10-Mar
4,5
Assembly Language, Data Transfer Operations
17-Mar
6,7
Arithmetic & Logical Operations
2.1,3.1, 3.2
24-Mar
8,9,10
Control Structures, Array/String & FP Operations
2.2,5,6
31-Mar
11,12
The CALL and RET Instructions, Multi-module
4.3, 4.4,4.6
07-Apr 13
Interfacing Assembly with HLL, Review
4.7
14-Apr
UTS
21-Apr 14
Compile-Assembly-Link-Load
1.4
28-Apr
15,16
Micro Architecture & Control Unit
05-Mei
17,18
Memori, Virtual Memory
5.1, 5.4, 5.5, 5.7
12-Mei
19,20
I/O: Polling & Interrupt, Exceptions
4.1, 4.2
19-Mei 21
Operasi Aritmatika: Mul & Div
6.3,6.6,6.7
26-Mei
Review

3. REVIEW

4. Review: Pengelompokkan Bit
Bit String:
INTEL
4 bit nibble
8 bit byte
16 bit word
32 bit double-word
64 bit quad-word
Alamat lokasi memori
umumnya dinyatakan dengan bilangan heksa desimal
contoh:
lokasi memori 90 pada memori dengan ruang memori sebesar 64K (65536 = 216) dinyatakan dengan alamat:
0x005A
jika ruang memori sebesar 232 (4G)
0x A

5. Review: Penyimpanan data multi-byte (Little Endian)
FFFFFFFF
Alamat (32 bit)
int i = 90;
90 = 0x5A = i j
int j = ;
= 0x000F1234 =

6. Review: Two’s Complement Numbers
two = 0ten two = 1ten two = 2ten two = 2,147,483,645ten two = 2,147,483,646ten two = 2,147,483,647ten two = –2,147,483,648ten two = –2,147,483,647ten two = –2,147,483,646ten two = –3ten two = –2ten two = –1ten
One zero, 1st bit is called sign bit
but one negative with no positive –2,147,483,648ten

7. Review: Sign extension
Convert 2’s complement number using n bits to more than n bits
Simply replicate the most significant bit (sign bit) of smaller to fill new bits
2’s comp. positive number has infinite 0s
2’s comp. negative number has infinite 1s
Bit representation hides leading bits; sign extension restores some of them
16-bit -4ten to 32-bit:
two
two

8. ARSITEKTUR INTEL X86: DARI PANDANGAN PEMROGRAM

9. Register: most frequently accessed operand
Registers are in the datapath of the processor;
if operands are in memory, we must transfer
them to the processor to operate on them,
And then transfer back to memory when done
Computer
Processor
Memory
Devices
Control
Input
Store
That is, any computer, no matter how primitive or advance, can be divided into five parts:
1. The input devices bring the data from the outside world into the computer.
2. These data are kept in the computer’s memory until ...
3. The datapath request and process them.
4. The operation of the datapath is controlled by the computer’s controller.
All the work done by the computer will NOT do us any good unless we can get the data back to the outside world.
5. Getting the data back to the outside world is the job of the output devices.
The most COMMON way to connect these 5 components together is to use a network of busses.
Datapath
Registers
Output
Load

10. Sumber Daya Komputasi: Register & Memori

11. Sumber Daya Komputasi: Set Instruksi
Data Transfers
memory-to-memory move
register-to-register move
memory-to-register move
Arithmetic & Logic
integer (binary + decimal) or FP
Add, Subtract, Multiply, Divide
shift left/right, rotate left/right
not, and, or, set, clear
Program Sequencing & Control
unconditional, conditional Branch
call, return
trap, return
Input/Output Transfers
register-to-i/o device move
Synchronization
test & set (atomic r-m-w)
String
search, translate
Graphics (MMX)
parallel subword ops (4 16bit add)

12. ORGANISASI MEMORI

13. Flat Memory Model
With the flat memory model, memory appears to a program as a single, continuous address space, called a linear address space.
The linear address space is byte addressable, with addresses running contiguously from 0 to
An address for any byte in the linear address space is called a linear address.

14. Segmented Memory Model
With the segmented memory model, memory appears to a program as a group of independent address spaces called segments. When using this model, code, data, and stacks are typically contained in separate segments.
To address a byte in a segment, a program must issue a logical address, which consists of a segment selector and an offset. The segment selector identifies the segment to be accessed and the offset identifies a byte in the address space of the segment.
The programs running on an IA processor can address up to 16,383 segments of different sizes and types, and each segment can be as large as 236 bytes.

15. Real-Address Mode Memory Model
The real-address mode model uses the memory model for the Intel 8086 processor, the first IA processor (for backward compatibility).
The real-address mode uses a specific implementation of segmented memory in which the linear address space for the program and the operating system/executive consists of an array of segments of up to 64 Kbytes in size each.
The maximum size of the linear address space in real-address mode is 220 bytes.

16. REGISTERS

17. x86 Registers
Program Counter (PC)

18. General Purpose Registers
GP Registers have additional, specific functions:
EAX Accumulator for operands and results data.
EBX Pointer to data in the DS segment.
ECX Counter for string and loop operations.
EDX I/O pointer.
ESI Pointer to data in the segment pointed to by the DS register; source pointer for string operations.
EDI Pointer to data (or destination) in the segment pointed to by the ES register; destination pointer for string operations.
ESP Stack pointer (in the SS segment).
EBP Pointer to data on the stack (in the SS segment).

19. Status Register: EFLAGS

20. Status Flags SF (bit 7) Sign flag ZF (bit 6) Zero flag
Set equal to the most-significant bit of the result, which is the sign bit of a signed integer. (0 indicates a positive value and 1 indicates a negative value.)
ZF (bit 6) Zero flag
Set if the result is zero; cleared otherwise.
CF (bit 0) Carry flag
Set if an arithmetic operation generates a carry or a borrow out of the most-significant bit of the result; cleared otherwise.
OF (bit 11) Overflow flag
Set if the integer result is too large a positive number or too small a negative number (excluding the sign-bit) to fit in the destination operand; cleared otherwise.
PF (bit 2) Parity flag
Set if the least-significant byte of the result contains an even number of 1 bits; cleared otherwise.
AF (bit 4) Adjust flag
Set if an arithmetic operation generates a carry or a borrow out of bit 3 of the result; cleared otherwise. Used in BCD arithmetic.

21. IF (bit 9) Interrupt enable flag
System Flags
IF (bit 9) Interrupt enable flag
Controls the response of the processor to maskable interrupt requests. Set to respond to maskable interrupts; cleared to inhibit maskable interrupts.
IOPL (bits 12, 13) I/O privilege level field
Indicates the I/O privilege level of the currently running program or task. The current privilege level (CPL) of the currently running program or task must be less than or equal to the I/O privilege level to access the I/O address space. This field can only be modified by the POPF and IRET instructions when operating at a CPL of 0.
NT (bit 14) Nested task flag
Controls the chaining of interrupted and called tasks. Set when the current task is linked to the previously executed task; cleared when the current task is not linked to another task.
VM (bit 17) Virtual-8086 mode flag
Set to enable virtual-8086 mode; clear to return to protected mode.

22. Used to hold 16-bit segment selectors
Segment Registers
Used to hold 16-bit segment selectors
CS code segment
where the instructions being executed are stored.
DS data segment
ES,FS,GS extra (data) segment
with possible configuration:
one for the data structures of the current module,
another for the data exported from a higher-level module,
a third for a dynamically created data structure,
a fourth for data shared with another program.
SS stack segment

23. Use of Segment Registers in Flat Memory Model
The segment registers are loaded with segment selectors that point to overlapping segments, each of which begins at address 0 of the linear address space.
Typically, two overlapping segments are defined: one for code (pointed to by CS) and another for data and stacks.

24. Use of Segment Registers in Segmented Memory Model
Each segment register is ordinarily loaded with a different segment selector so that each segment register points to a different segment (up to 6 segments) within the linear address space.

25. Data Storage

26. Storage of Fundamental Data Type

27. Storage of Numeric Data Type

28. PROCESSOR OPERATION MODE

29. 3 Modes of Operation Protected mode Real-address mode
the native state of the processor
all instructions and architectural features are available, providing the highest performance and capability
recommended mode for all new applications and operating systems
the processor can use any of the memory models
ability to directly execute “real-address mode” 8086 software in a protected, multitasking environment: virtual-8086 mode
Real-address mode
provides the programming environment of the Intel 8086 processor with a few extensions
the processor is placed in real-address mode following power-up or a reset
only supports the real-address mode memory model
System management mode
provides an operating system with a transparent mechanism for implementing platform-specific functions such as power management and system security
the processor enters SMM when the external SMM interrupt pin (SMI#) is activated or an SMI is received from the advanced programmable interrupt controller (APIC)
in SMM, the processor switches to a separate address space while saving the entire context of the currently running program or task

30. Protected Mode
a (segment) selector value is an index into a descriptor table.
the segments are not at fixed positions in physical memory. In fact, they do not have to be in memory at all!
Protected mode uses a technique called virtual memory. The basic idea of a virtual memory system is to only keep the data and code in memory that programs are currently using.
16-bit:
offsets are still 16-bit quantities. As a consequence of this, segment sizes are still limited to at most 64K.
32-bit:
offsets are expanded to be 32-bits. This allows an oset to range up to 4 billion. Thus, segments can have sizes up to 4 gigabytes.
segments can be divided into smaller 4K-sized units called pages.
In Windows 3.x:
standard mode referred to bit protected mode
enhanced mode referred to 32-bit mode.
Windows 9X, Windows NT/2000/XP, OS/2 and Linux all run in paged 32-bit protected mode.

31. 20-bit address is constructed using 2 16-bit values:
Real Mode
In real mode, memory is limited to only 1M (220) bytes. Valid address range from 0x00000 to 0xFFFFF.
20-bit address is constructed using 2 16-bit values:
The first 16-bit value is called the selector, stored in segment register.
The second 16-bit value is called the offset.
The physical address referenced by a 32-bit selector:offset pair is computed by the formula:
16*selector + offset
multiplying by 16 in hex is easy, just add a 0 to the right of the number
for example, the physical addresses referenced by 047C:0048 is given by: 047C = 04808

32. Contoh program dalam real-mode
hello_m.asm:
segment .text
..start:
mov ax,DATA
mov ds,ax
mov dx,hello
mov ah,9
int 0x21
....
segment DATA
hello: db 'hello, world', 13, 10, '$‘
debug hello_m.exe:
AX=0B3D BX=FFFF CX=FE5A DX=0000 SP=010A BP=0000 SI=0000 DI=0000
DS=0B3C ES=0B2B SS=0B3D CS=0B3B IP=000D NV UP EI PL NZ NA PO NC
0B3B:000D BA0B MOV DX,000B
-d ds:b
0B3C: C 6C 6F hello
0B3C: C F 72 6C 64 0D-0A , world..$......

33. Intel x86 Assembly Program

34. NASM Assembly-Program Format
[label:] instruction operands ; comment
label: optional
represents the address of memory location storing the instruction
to be used as reference for:
data access
jump-address
instruction:
data transfer
arithmetic & logic
program sequencing & control
i/o
...
operands:
register
memory
immediate
implied
comment
no comment 

35. LABEL

36. lokasi instruksi Review: The Program is ...
Add 8,4,6 ; 8  [4] + [6]
; [8] = = 78
Sub 6,8,6 ; 6  [8] – [6]
; [6] = 78 – 17 = 61
can be represented by labels

37. Label Label: label1 ; some code .loop ; some more code jne .loop ret
Valid characters in labels are:
letters, numbers, _, $, ~, ., and ?
The only characters which may be used as the first character of an identifier are:
letters, . (period), _, ?
A label beginning with a single period is treated as a local label, which means that it is associated with the previous non-local label. So, for example:
label1 ; some code
.loop ; some more code
jne .loop
ret
label2 ; some code

38. Contoh: label dalam tugas0a.asm*
segment .data
data1 db 11h
data2 dw 2222h
data3 dd h
datatmp times 9 db 0ffh
segment .bss
stacks resd 1
segment .text
global _asm_main
_asm_main:
mov eax,10 ; decimal number, value = 10
mov edx,eax ; register-to-register transfer
mov esi,data1 ; esi points to data1
mov al,[esi] ; indirect memory access, load 1 byte
mov bx,[esi] ; indirect memory access, load 1 word
mov ecx,[esi] ; indirect memory access, load 1 double-word
mov edi,[data3] ; direct memory operand

39. INSTRUCTIONS

40. Review: Bahasa Mesin  Bahasa Rakitan
Bahasa Mesin  kumpulan bit yang merepresentasikan Operasi & Operand
Bahasa Rakitan  representasi dari Bahasa Mesin dalam bahasa (kumpulan huruf & angka) yang lebih mudah dimengerti oleh manusia
Bahasa Mesin
Bahasa Rakitan
0846: Add (8),(4),(6)
8  [4] + [6]
Register Transfer Notation
mnemonic

41. Register Transfer Notation
Notasi yang menggambarkan proses pertukaran data yang terjadi pada eksekusi instruksi:
arah: dari sumber ke tujuan
operasi: ‘+’, ‘-’, …
Sumber/Tujuan Data:
Register
Memori
I/O Device
Nilai/content dari sumber data dinyatakan dengan
[sumber-data]
Contoh:
Pertukaran data:
Move R1,LOC R1  [LOC] ; isi lokasi memori ‘Loc’ di ; copy-kan ke register R1
Operasi:
Add R3,R1,R2 R3  [R1] + [R2] ; isi register R1 dijumlahkan ; dengan isi register R2, ; hasilnya disimpan di ; register R3

42. Review: Jumlah Operand  Kelas Set Instruksi
3-address instruction
Add C,A,B ; C [A] + [B]
Operation Destination,Source1,Source2
atau
Operation Source1,Source2,Destination
2-address instruction
Add A,B ; A  [A] + [B]
Operation Destination,Source
Format Instruksi Intel x86
1-address instruction
Load B ; acc  B
Add A ; acc [acc] + [A]
Invented index register
Reverse polish stack = HP calculator
GPR = last 20 years
L/S variant = last 10 years
0-address instruction
Push B ; tos  B
Push A ; tos  A; [next] = B
Add ; tos [tos] + [next]

43. Instruction Format Ukuran instruksi [n] bervariasi: 1  n  16 byte
0, 1, 2, 3, , ,1 0, , 1, 2, 3, , 1, 2, 3, 4
Prefix: (Lock, Repeat), Overrides: Segment, Operand Size, Address Size
ModR/M: Addressing Mode
SIB: Scale, Index, Base
Displacement: Displacement’s Value
Immediate: Immediate’s Value
Konvensi: OPcode dst,src ; dst  [dst] OP [src]
Contoh:
MOV EAX,EBX ; register
MOV EAX,[DATA] ; displacement
MOV EAX,0x10 ; immediate
REP MOV EDX,EAX ; prefix: REP
MOV EAX,[EBP+4*ESI+Offset] ; base+index*scale+displacement
...
Prefix
Displacement
Immediate
SIB
Opcode
Mod
R/M

44. OPERANDS

45. Operand Addressing Register Immediate Memory
refers to the data (content) of a register
mov eax,ebx
89 d8
Immediate
refers to a fixed value that is hard-coded into the instruction itself
mov eax,0x10 b
Memory
refers to the data (content) of a memory location
mov eax,[data] ; eax  [data] (direct memory access)
a1 d ; data is located at 0x000092d0
mov eax,[ebx] ; eax  [[ebx]] (indirect memory access)
8b 03 ; data location = [ebx]
EAX
100
EBX
100
EAX 0x
0xb8 0x

46. (Direct) Memory Operand
DATA DD 0x0000FFFF
...
MOV EAX,[DATA] ; EAX  [DATA]
MOV EAX,[0x000090D0] ; EAX  [0x000090D0]
DATA = 0x000092D0 …
MOV EAX,[DATA]
0x0000FFFF
EAX
0x0000FFFF

47. (Indirect) Memory Operand
DATA DD 0x0000FFFF
...
MOV EBX,DATA ; EBX  DATA=0x000092D0
MOV EAX,[EBX] ; EAX  [[EBX]]
MOV EBX,DATA 0x
0x000092D0
MOV EAX,[EBX]
EBX
0x000092D0
0x0000FFFF
EAX
0x0000FFFF

48. Source and destination operands can be any of:
Register Operands
Source and destination operands can be any of:
32-bit GP registers: EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP
16-bit GP registers: AX, BX, CX, DX, SI, DI, SP, BP
8-bit GP registers: AH, BH, CH, DH, AL, BL, CL, DL
segment registers: CS, DS, SS, ES, FS, GS
EFLAGS register
system registers: GDTR (global descriptor table), IDTR (interrupt descriptor table register)
Some instructions (DIV & MUL) use quadword operands contained in a pair of 32-bit registers.
EDX:EAX  EDX: high-order dword, EAX: low-order dword
Contoh:
mul ebx ; edx:eax  [eax] * [ebx]

49. Contoh: register-operand dalam tugas0a.asm*
segment .data
data1 db 11h
data2 dw 2222h
data3 dd h
datatmp times 9 db 0ffh
segment .bss
stacks resd 1
segment .text
global _asm_main
_asm_main:
mov eax,10 ; decimal number, value = 10
mov edx,eax ; register-to-register transfer
mov esi,data1 ; esi points to data1
mov al,[esi] ; indirect memory access, load 1 byte
mov bx,[esi] ; indirect memory access, load 1 word
mov ecx,[esi] ; indirect memory access, load 1 double-word
mov edi,[data3] ; direct memory operand

50. Immediate Operands
The maximum value allowed for an immediate operand varies among instructions, but can never be greater than the maximum value of an unsigned doubleword integer (232).
Numeric
mov eax,100 ; decimal
add eax,0a2h ; hex
and eax,0xa2 ; hex again
imul eax,ebx,242q ; octal
push b ; binary
Character
mov eax,'abcd'
All arithmetic instructions (except DIV & IDIV instructions) allow the source operand to be an immediate value. a b c d

51. Contoh: immediate-operand dalam tugas0a.asm*
segment .data
data1 db 11h
data2 dw 2222h
data3 dd h
datatmp times 9 db 0ffh
segment .bss
stacks resd 1
segment .text
global _asm_main
_asm_main:
mov eax,10 ; decimal number, value = 10
mov edx,eax ; register-to-register transfer
mov esi,data1 ; esi points to data1
mov al,[esi] ; indirect memory access, load 1 byte
mov bx,[esi] ; indirect memory access, load 1 word
mov ecx,[esi] ; indirect memory access, load 1 double-word
mov edi,[data3] ; direct memory operand

52. The segment selector can be specified either implicitly or explicitly:
Memory Operands (1/2)
The Effective Address of memory operands are computed by means of a segment selector and an offset.
The segment selector can be specified either implicitly or explicitly:
the most common method of specifying a segment selector is to load it in a segment register and then allow the processor to select the register implicitly, depending on the type of operation being performed.
Default Segment Selection Rules:
CS: instruction fetches JMP _MAIN
SS: stack pushes & pops; references using ESP & EBP PUSH EAX
DS: data references, except when relative to stack MOV EAX,[DATA]
ES: destination of string operations

53. [Base] + [Index]*Scale factor + Displacement
Memory Operands (2/2)
Offset calculation:
[Base] + [Index]*Scale factor + Displacement
Displacement: An 8-, 16-, or 32-bit value.
Base: the value in a general-purpose register.
Index: the value in a general-purpose register.
Scale factor: a value of 2, 4, or 8 that is multiplied by the index value. 8 4

54. Contoh: memory-operand dalam tugas0a.asm*
segment .data
data1 db 11h
data2 dw 2222h
data3 dd h
datatmp times 9 db 0ffh
segment .bss
stacks resd 1
segment .text
global _asm_main
_asm_main:
mov eax,10 ; decimal number, value = 10
mov edx,eax ; register-to-register transfer
mov esi,data1 ; esi points to data1
mov al,[esi] ; indirect memory access, load 1 byte
mov bx,[esi] ; indirect memory access, load 1 word
mov ecx,[esi] ; indirect memory access, load 1 double-word
mov edi,[data3] ; direct memory operand

55. Contoh: memory-operand [base+index*scale+disp]
struct Point {
int x;
int y;
} p[ ] = { {0,0}, {1,1} };
for (i=0; i<3; i++) {
x += p[i].x;
y += p[i].y; }
_p dd 0, 0, 1, 1
...
mov ebx,_p
mov esi,_i
add eax,[ebx+8*esi+0]
add edx,[ebx+8*esi+4]

56. DIRECTIVES

57. SECTION or SEGMENT
The SECTION (SEGMENT) directive changes which section of the output file the code you write will be assembled into.
The Unix (coff, elf, ...) object formats, and the bin object format, all support the standardised section names:
.text ; code’s segment
.data ; (initialized) data’s segment
.bss ; uninitialized data’s segment

58. EXTERN & GLOBAL
EXTERN is similar to the C keyword extern: it is used to declare a symbol which is not defined anywhere in the module being assembled, but is assumed to be defined in some other module and needs to be referred to by this one
extern _printf
extern _sscanf,_fscanf
GLOBAL is the other end of EXTERN: if one module declares a symbol as EXTERN and refers to it, then in order to prevent linker errors, some other module must actually define the symbol and declare it as GLOBAL. Some assemblers use the name PUBLIC for this purpose.
The GLOBAL directive applying to a symbol must appear before the definition of the symbol.
global _main
_main: ; some code

59. Contoh: directives dalam tugas0a.asm*
segment .data
data1 db 11h
data2 dw 2222h
data3 dd h
datatmp times 9 db 0ffh
segment .bss
stacks resd 1
segment .text
global _asm_main
_asm_main:
mov eax,10 ; decimal number, value = 10
mov edx,eax ; register-to-register transfer
mov esi,data1 ; esi points to data1
mov al,[esi] ; indirect memory access, load 1 byte
mov bx,[esi] ; indirect memory access, load 1 word
mov ecx,[esi] ; indirect memory access, load 1 double-word
mov edi,[data3] ; direct memory operand

60. PSEUDO-INSTRUCTIONS

61. DB and friends: Declaring Initialised Data
DB, DW, DD, DQ and DT are used to declare initialized data in the output file.
db 0x55 ; just the byte 0x55
db 0x55,0x56,0x57 ; three bytes in succession
db 'a',0x55 ; character constants are OK
db 'hello',13,10,'$' ; so are string constants
dw 0x ; 0x34 0x12
dw 'a' ; 0x41 0x00 (it's just a number)
dw 'ab' ; 0x41 0x42 (character constant)
dw 'abc' ; 0x41 0x42 0x43 0x00 (string)
dd 0x ; 0x78 0x56 0x34 0x12
dd e20 ; floating-point constant
dq e20 ; double-precision float
dt e20 ; extended-precision float

62. RESB and friends: Declaring Uninitialised 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.
buffer: resb 64 ; reserve 64 bytes
wordvar: resw 1 ; reserve a word
realarray: resq 10 ; array of ten reals

63. EQU: 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.
header_len equ 16
...
mov ecx,header_len ; eax  16

64. TIMES: Repeating Instructions or Data
The TIMES prefix causes the instruction to be assembled multiple times.
zerobuf: times 64 db 0
...
times 100 movsb

65. Contoh: pseudo-instructions dalam tugas0a.asm*
segment .data
data1 db 11h
data2 dw 2222h
data3 dd h
datatmp times 9 db 0ffh
segment .bss
stacks resd 1
segment .text
global _asm_main
_asm_main:
mov eax,10 ; decimal number, value = 10
mov edx,eax ; register-to-register transfer
mov esi,data1 ; esi points to data1
mov al,[esi] ; indirect memory access, load 1 byte
mov bx,[esi] ; indirect memory access, load 1 word
mov ecx,[esi] ; indirect memory access, load 1 dword
mov edi,[data3]; direct memory operand

66. EXPRESSIONS

67. $$ evaluates to the beginning of the current section;
Special Expressions
NASM supports two special tokens in expressions, allowing calculations to involve the current assembly position: the $ and $$ tokens.
$ evaluates to the assembly position at the beginning of the line containing the expression;
message db 'hello, world'
msglen equ $-message
buffer: db 'hello, world' times 64-$+buffer db ' ‘
so you can code an infinite loop using JMP $.
$$ evaluates to the beginning of the current section;
so you can tell how far into the section you are by using ($-$$).

68. Operators |: Bitwise OR Operator ^: Bitwise XOR Operator
&: Bitwise AND Operator
bitwise AND
<< and >>: Bit Shift Operators
<< gives a bit-shift to the left, >> gives a bit-shift to the right
in NASM, such a shift is always unsigned
+ and -: Addition and Subtraction Operators
do perfectly ordinary addition and subtraction
*, /, //, % and %%: Multiplication and Division
* is the multiplication operator
/ is unsigned division and // is signed division
% and %% provide unsigned and signed modulo operators
Unary Operators: +, -, ~ and SEG
- negates its operand
+ does nothing (it's provided for symmetry with -)
~ computes the one's complement of its operand
SEG provides the segment address of its operand

69. Contoh: expressions dalam tugas0a.asm*
segment .data
data1 db (1<<4)|1 ; [data1] = 11h
data2 dw 2222h
data3 dd h
datatmp times 9 db 0ffh
segment .bss
stacks resd 1
segment .text
global _asm_main
_asm_main:
mov eax,~0xEF&0xFF ; decimal number, value = 10
mov edx,eax ; register-to-register transfer
mov esi,data1 ; esi points to data1
mov al,[esi] ; indirect memory access, load 1 byte
mov bx,[esi] ; indirect memory access, load 1 word
mov ecx,[esi] ; indirect memory access, load 1 dword
mov edi,[data3]; direct memory operand

70. CONTOH PROGRAM

71. hello.asm extern _printf segment .data the_str db "hello world", 10, 0
segment .text
global _asm_main
_asm_main:
enter 0,0
pusha
push dword the_str
call _printf ; printf(“hello world\n”)
pop eax
popa
mov eax,0 ; return back to main() – driver.c
leave
ret

72. EVALUASI TUGAS0

73. tugas0a.asm segment .data data1 db 11h data2 dw 2222h
data3 dd h
data4 times 16 db 0
mov eax,10 ; eax =
mov ebx,10b ; ebx =
mov ecx,10h ; ecx =
mov edx,eax ; edx =
mov esi,data1 ; esi =
mov al,[esi] ; eax =
mov bx,[esi] ; ebx =
mov ecx,[esi] ; ecx =
mov edx,[data1] ; edx =
mov esi,[data2] ; esi =
mov edi,[data3] ; edi =
mov [data4],dl ; [data4] =
mov [data4],dx ; [data4] =
mov [data4],edx ; [data4] =
0x a 0x 0x
0x0000c8d0; [0x0000c8d0] = 0x11, 0x22, 0x22, 0x33
0x33, 0x33, 0x33, 0xff 0x 0x 0x 0x 0x
0x11, 0x00, 0x00, 0x00; data4=0x0000c8e0
0x11, 0x22, 0x00, 0x00
0x11, 0x22, 0x22, 0x33