BT Bit Test (386+)

Flags affected:

O

D

I

T

S

Z

A

P

C

OF: Overflow flag TF: Trap flag AF: Aux carry

F

F

F

F

F

F

F

F

F

DF: Direction

flag SF: Sign

flag

PF: Parity flag

* IF: Interrupt

flag ZF: Zero

flag

CF: Carry flag

Legal forms:

BT r16,r16	386+
BT m16,r16	386+
BT r32,r32	386+
BT m32,r32	386+
BT r16,i8	386+
BT m16,i8	386+
BT r32,i8	386+
BT m32,i8	386+

Examples:

BT AX,CX

BT [BX+DI],DX

BT AX,64

BT EAX,EDX

BT ECX,17

Notes:

BT copies a single specified bit from the left operand to the Carry flag, where it can be tested or fed back into a quantity using one of the shift/rotate instructions. Which bit is copied is specified by the right operand. Neither operand is altered by BT.

When the right operand is an 8-bit immediate value, the value specifies the number of the bit to be copied. In BT AX,5, bit 5 of AX is copied into CF. When the immediate value exceeds the size of the left operand, the value is expressed modulo the size of the left operand. That is, because there are not 66 bits in EAX, BT EAX,66 pulls out as many 32s from the immediate value as can be taken, and what remains is the bit number. (Here, 2.) When the right operand is not an immediate value, the right operand not only specifies the bit to be tested but also an offset from the memory reference in the left operand. This is complicated. See a detailed discussion in a full assembly language reference.

r8 = AL AH BL BH CL CH DL DH sr = CS DS SS ES FS GS

m8 = 8-bit memory data

m32 = 32-bit memory data

i16 = 16-bit immediate data

d8 = 8-bit signed displacement

d32 = 32-bit unsigned displacement

r16 = AX BX CX DX BP SP SI DI

r32 = EAX EBX ECX EDX EBP ESP ESI E m16 = 16-bit memory data

i8 = 8-bit immediate data

i32 = 32-bit immediate data

d16 = 16-bit signed displacement

CALL Call Procedure

Flags affected:

O

D

I

T

S

Z

A

P

C

OF:

Overflow flag TF:

Trap

flag

AF:

Aux carry

F

F

F

F

F

F

F

F

F

DF:

Direction flag SF:

Sign

flag

PF:

Parity flag

<none> IF: Interrupt flag ZF: Zero flag CF: Carry flag

Legal forms:

CALL <near label>
CALL <far label>
CALL r16
CALL m16	386+
CALL r32
CALL m32	386+

Examples:

CALL InsideMySegment	;InsideMySegment is a Near label
CALL OutsideMySegment	;OutsideMySegment is a Far label
CALL BX
CALL EDX	;Calls Near address at [BX+DI+17]
CALL WORD [BX+DI+17]
CALL DWORD [BX+DI+17]	;Calls full 32-bit address at [BX+DI+17]

Notes:

CALL transfers control to a procedure address. Before transferring control, CALL pushes the address of the instruction immediately after itself onto the stack. This allows a RET instruction (see also) to pop the return address into either CS:IP or IP only (depending on whether it is a Near or Far call) and thus return control to the instruction immediately after the CALL instruction.

In addition to the obvious CALL to a defined label, CALL can transfer control to a Near address within a 16-bit general-purpose register, and also to an address located in memory. These are shown in the Legal Forms column as m16 and m32. m32 is simply a full 32-bit address stored at a location in memory that may be addressed through any legal x86 memory-addressing mode. CALL m16 and CALL m32 are useful for creating jump tables of procedure addresses.

There are many more variants of the CALL instruction with provisions for working with the protection mechanisms of operating systems. These are not covered here, and for more information you should see an advanced text or a full assembly language reference.

r8 = AL AH BL BH CL CH DL DH sr = CS DS SS ES FS GS

m8 = 8-bit memory data

m32 = 32-bit memory data

i16 = 16-bit immediate data

d8 = 8-bit signed displacement

d32 = 32-bit unsigned displacement

r16 = AX BX CX DX BP SP SI DI

r32 = EAX EBX ECX EDX EBP ESP ESI E m16 = 16-bit memory data

i8 = 8-bit immediate data

i32 = 32-bit immediate data

d16 = 16-bit signed displacement

CLC Clear Carry Flag (CF)

Flags affected:

O

D

I

T

S

Z

A

P

C

OF: Overflow flag TF: Trap flag AF: Aux carry

F

F

F

F

F

F

F

F

F

DF: Direction

flag SF: Sign

flag

PF: Parity flag

* IF: Interrupt

flag ZF: Zero

flag

CF: Carry flag

Legal forms:

CLC <none>

Examples:

CLC

Notes:

CLC simply sets the Carry flag (CF) to the cleared (0) state. Use CLC in situations where the Carry flag must be in a known cleared state before work begins, as when you are rotating a series of words or bytes using the rotate instructions RCL and RCR. It can also be used to put CF into a known state before returning from a procedure, to indicate that the procedure had succeeded or failed, as desired.

r8	= AL AH	BL BH CL CH	DL DH	r16	= AX BX CX DX BP SP SI DI
sr = CS DS SS ES FS GS				r32	= EAX EBX ECX EDX EBP ESP ESI E
m8	= 8-bit memory data			m16	= 16-bit memory data
m32	= 32-bit memory data			i8	= 8-bit immediate data
i16	= 16-bit immediate		data	i32	= 32-bit immediate data
d8	= 8-bit signed displacement			16	= 16-bit signed displacement
d32	= 32-bit unsigned displacement

CLD Clear Direction Flag (DF)

Flags affected:

O

D

I

T

S

Z

A

P

C

OF: Overflow flag TF: Trap flag AF: Aux carry

F

F

F

F

F

F

F

F

F

DF: Direction

flag SF: Sign

flag

PF: Parity flag

*

IF: Interrupt

flag ZF: Zero

flag

CF: Carry flag

Legal forms:

CLD <none>

Examples:

CLD

Notes:

CLD simply sets the Direction flag (DF) to the cleared (0) state. This affects the adjustment performed by repeated string instructions such as STOS, SCAS, and MOVS. Typically, when DF = 0, the destination pointer is increased, and decreased when DF = 1. DF is set to one with the STD instruction.

r8 = AL AH BL BH CL CH DL DH sr = CS DS SS ES FS GS

m8 = 8-bit memory data

m32 = 32-bit memory data

i16 = 16-bit immediate data

d8 = 8-bit signed displacement

d32 = 32-bit unsigned displacement

r16 = AX BX CX DX BP SP SI DI

r32 = EAX EBX ECX EDX EBP ESP ESI E m16 = 16-bit memory data

i8 = 8-bit immediate data

i32 = 32-bit immediate data

d16 = 16-bit signed displacement