Assembly Procedures and Functions (Win32 Only)

You can write complete procedures and functions using inline assembly language code, without including a begin...end statement. This topic covers these issues:

Compiler Optimizations.
Function Results.

The inline assembler is available only on the Win32 Delphi compiler.

Compiler Optimizations

An example of the type of function you can write is as follows:

Copy Code

function LongMul(X, Y: Integer): Longint;
  asm
    MOV     EAX,X
                IMUL Y 
        end;

The compiler performs several optimizations on these routines:

No code is generated to copy value parameters into local variables. This affects all string-type value parameters and other value parameters whose size isn't 1, 2, or 4 bytes. Within the routine, such parameters must be treated as if they were var parameters.
Unless a function returns a string, variant, or interface reference, the compiler doesn't allocate a function result variable; a reference to the @Result symbol is an error. For strings, variants, and interfaces, the caller always allocates an @Result pointer.
The compiler only generates stack frames for nested routines, for routines that have local parameters, or for routines that have parameters on the stack.
Locals is the size of the local variables and Params is the size of the parameters. If both Locals and Params are zero, there is no entry code, and the exit code consists simply of a RET instruction.

The automatically generated entry and exit code for the routine looks like this:

Copy Code

PUSH            EBP                                 ;Present if Locals <> 0 or Params <> 0
MOV             EBP,ESP                 ;Present if Locals <> 0 or Params <> 0
SUB             ESP,Locals      ;Present if Locals <> 0
.
.
.
MOV             ESP,EBP                 ;Present if Locals <> 0
POP             EBP                                 ;Present if Locals <> 0 or Params <> 0
RET             Params                      ;Always present

If locals include variants, long strings, or interfaces, they are initialized to zero but not finalized.

Function Results

Assembly language functions return their results as follows.

Ordinal values are returned in AL (8-bit values), AX (16-bit values), or EAX (32-bit values).
Real values are returned in ST(0) on the coprocessor's register stack. (Currency values are scaled by 10000.)
Pointers, including long strings, are returned in EAX.
Short strings and variants are returned in the temporary location pointed to by @Result.