Inline Assembler

It supports both 16-bit and 32-bit code generation in all memory models.

What's in This Chapter

• Basic features of the inline assembler.
• The ASM statement and the ASM block.
• Using ASM registers.
• Calling C and C++ from assembly language.
• Registers and opcodes.

Advantages of writing inline assembly language functions

• Create a subroutine that executes as quickly as possible
• Provide an interface to functions compiled with another compiler
• Acess capabilities of the CPU and the native instruction set that are not available from C++
• Interface to specialized hardware
• Write code where specific instruction selection and ordering is critical

The asm Statement

The first example shows asm followed simply by an assembly instruction:

asm mov AH,2
asm mov DL,7 
asm int 21H

asm { 
    mov AH,2
    mov DL,7 
    int 21H
} 

asm mov AH,2 asm mov DL,7 asm int 21H 

No assembler instruction can continue onto a second line. Use the form of the last example primarily for writing macros, which must be one line long after expansion.

Note

The ASM Block

Restrictions on using C and C++ in an ASM block

• Symbols, including labels, variables, and function names.
• Constants, including symbolic constants and enum members.
• Macros and preprocessor directives.
• Comments delimited by /**/ symbols or defined by // symbols. In Microsoft-compatible mode, semicolons (;) can also be used to delimit comments.
• Type names (where a MASM type would be legal).
• Type names, including declarations of structs and pointers.
• C-style type casts.

Note

Inline assembly instructions within C or C++ statements can refer to C or C++ variables by name.

MASM-Style hexadecimal constants

	digit {hex_digit} ('H'| 'h') 

C and C++ operators in an ASM block

You can use operators common to C, C++, and MASM within an ASM block but interpret them as assembly language operators. C and C++ interpret brackets ([]) as enclosing array subscripts and scale them to the size of an array element. But within an asm statement, C and C++ interpret brackets as the MASM index operator, which adds an unscaled byte offset to any adjacent operand.

In Microsoft-compatible mode, the semicolon delimits comments, as in MASM.

Assembly language in an asm statement

• Expressions. Inline assembly code can use any MASM expression. A MASM expression is any combination of operands and operators that evaluates to a single value or address.
• Data directives and operators. An asm statement can define data objects in the code segment with the MASM directives DB, DW, and DQ. The MASM directives DT, DF, STRUC, and RECORD, and the operators DUP, THIS, WIDTH, and MASK are not accepted.
• Macros. An asm statement can use C preprocessor macros even though the inline assembler is not a macro assembler and does not support MASM macro directives.

Other restrictions on C and C++ symbols

Prototype the functions referenced in an asm statement before using them in programs. This lets the compiler distinguish them from names and labels.

Each assembly language instruction can contain a single C or C++ symbol.

C or C++ symbols within an ASM block must not have the same spelling as an asm reserved word.

The inline assembler allows structure or union tags in asm statements, but only as qualifiers of references to members of the structure or union.

Accessing C or C++ data in an asm statement

	asm mov AX,var

	struct first_type
	{ 
	    char *mold;
	    int common_name; 
	};

	struct second__type
	{ 
	    char *mildew;
	    long common_name; 
	    int unique_name;
	}; 

	asm mov [bx]first_type.common_name,10 

	asm mov [bx].unique_name,10 

Functions in inline assembly language

The expon2 function is an example of a function written in inline assembly language:

	int expon2(int num, int power)
	{
	    asm 
	    {	mov AX,num	// get first argument 
		mov CX,power	// get second argument
		shl AX,CL	// AX = AX * (2 to the power of CL) 
	    }
	} 

Refer to Using Assembly Language Functions for a description of the register stacks used by inline assembly instructions.

Making anonymous references to structure members

	struct x {
	    int i; 
	    int j;
	    int k; 
	} foo; 

	asm
	{   mov BX,4 
	    mov AX,foo[BX]; Refers to member j of foo
	} 

Using register variables

For more information see "Using Register Variables" in Using Assembly Language Functions.

Using the __LOCAL_SIZE symbol

For example:

	__declspec(naked) int test()
	{
	    int x, y, z; 

	    _asm
	    {	push BP 
		mov BP,SP
		sub SP,__LOCAL_SIZE 
		mov BX,__LOCAL_SIZE[BP]
		mov BX,__LOCAL_SIZE+2[BP] 
		mov AX,__LOCAL_SIZE
		mov AX,__LOCAL_SIZE+2 
	    }
	    _AX = x + y + z; 
	    _asm
	    { 
		mov SP,BP
		pop BP 
		ret
	    } 
	} 

Using ASM Registers

For 16-bit memory models

C and C++ do not expect these registers to be maintained between statements, but they do preserve the following registers: CS, DS, SS, SP and BP.

Note

For 32-bit memory models

Functions must preserve the values in the EBX, ESI, EDI, EBP, ESP, SS, CS, DS registers (plus ES and GS for the NT memory model).

Always set the direction flag to forward.

To maximize speed on 32-bit buses, make sure data aligns along 32-Function return values

• For 16-bit models. If the return value for a function is short (a char, int, or near pointer) store it in the AX register, as in the previous example, expon2. If the return value is long, store the high word in the DX register and the low word in AX. To return a longer value, store the value in memory and return a pointer to the value.
• For 32-bit models. Return near pointers, ints, unsigned ints, chars, shorts, longs and unsigned longs in EAX. 32-bit models return far pointers in EDX, EAX, where EDX contains the segment and EAX contains the offset.
• When C linkage is in effect. Floats are returned in EAX and doubles in EDX, EAX, where EDX contains the most significant 32 bits and EAX the least significant.
• When C++ linkage is in effect. The compiler creates a temporary copy on the stack and returns a pointer to it.

Function return values

• For 16-bit memory models. If the return value for a function is short (a char, int, or near pointer) store it in the AX register, as in the previous example, expon2. If the return value is long, store the high word in the DX register and the low word in AX. To return a longer value, store the value in memory and return a pointer to the value.
• For 32-bit models. Return near pointers, ints, unsigned ints, chars, shorts, longs, and unsigned longs in EAX. 32-bit models return far pointers in EDX, EAX, where EDX contains the segment and EAX contains the offset.
• When C linkage is in effect. Floats are returned in EAX and doubles in EDX, EAX, where EDX contains the most significant 32 bits and EAX the least significant.
• When C++ linkage is in effect. The compiler creates a temporary copy on the stack and returns a pointer to it.

Interfacing to a member function

An alternative is to write the member function in C++ and compile it with normal out-of-line member functions.

Calling C Functions from an ASM Block

	#include <stdio.h> 
	char format [] = "% s %s %s \n";
	char alas[] = "Alas,"; 
	char poor[] = "poor";
	char Yorick[] = "Yorick!"; 

	void main(void) 
	{
	    asm 
	    {	mov	AX, offset Yorick 
		push	AX
		mov	AX, offset poor 
		push	AX
		mov	AX, offset Alas 
		push	AX
		mov	AX, offset format 
		push	AX
		call	printf 
	    }
	} 

Calling C++ functions

You can also call a function declared with extern "C" linkage from an asm statement within a C++ program, because all the standard header files declare the library functions to have extern "C" linkage.

Defining ASM blocks as C macros

If the macro expands into multiple instructions, enclose the instructions in an ASM block. The asm statement must precede each instruction. Also separate comments from code with /**/ characters rather than //. Unless you take these precautions, the compiler can be confused by C or C++ statements to the left or right of the assembly code or interpret instructions as comments when the macro becomes a single line. Without the closing brace, the compiler cannot tell where the assembly language ends.

Warning: Do not use double-slash (//) characters within a macro. The compiler terminates the macro when it sees a double-slash.

An ASM block written as a macro can accept arguments but, unlike a C macro, it cannot return values. But some MASM macros can be written as macros for C. The following MASM macro sets a video page to the value specified in the argument page:

	findpage MACRO page
		mov AH, 5 
		MOV AL,page
		int 10h 
		ENDM 

	#define findpage(page) asm \
	{ \
	    asm mov AH,5 \
	    asm mov AL,page \
	    asm int 10h \
	} 

Registers

AL, AH, AX, EAX

BL, BH, BX, EBX

CL, CH, CX, ECX

DL, DH, DX, EDX

BP, EBP

SP, ESP

DI, EDI

SI, ESI

ES, CS, SS, DS, GS, FS

CR0, CR2, CR3, CR4

DR0, DR1, DR2, DR3, DR6, DR7

TR3, TR4, TR5, TR6, TR7

ST

ST(0), ST(1), ST(2), ST(3), ST(4), ST(5), ST(6), ST(7)

MM0, MM1, MM2, MM3, MM4, MM5, MM6, MM7

XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7

Opcodes

Pentium 4 (Prescott) Opcodes Supported

AMD Opcodes