Announcement

**Nico Bendlin** · 07.10.2002, 00:58

Die Reihenfolge (left-to-right, right-to-left), der Ort der Parameter (stack, register) und wer den Stack aufzuräumen hat, hängt von der Aufrufkonvention der Funktion ab.

Hier ein Beispiel mit allen Aufrufkonventionen, die von Delphi unterstützt...

<pre>program Project1;

uses
Windows;

function FooRegister(x, y, z: Byte): Integer; register;
asm
// Result = x
AND EAX, 0000000FFH
// Result += y
AND EDX, 0000000FFH
ADD EAX, EDX
// Result += z
AND ECX, 0000000FFH
ADD EAX, ECX
end;

function FooPascal(x, y, z: Byte): Integer; pascal;
asm
// Result = x
XOR EAX, EAX
MOV AL, BYTE PTR [EBP + 010H]
// Result += y
XOR EDX, EDX
MOV DL, BYTE PTR [EBP + 00CH]
ADD EAX, EDX
// Result += z
XOR EDX, EDX
MOV DL, BYTE PTR [EBP + 008H]
ADD EAX, EDX
end;

function FooCDecl(x, y, z: Byte): Integer; cdecl;
asm
// Result = x
XOR EAX, EAX
MOV AL, BYTE PTR [EBP + 008H]
// Result += y
XOR EDX, EDX
MOV DL, BYTE PTR [EBP + 00CH]
ADD EAX, EDX
// Result += z
XOR EDX, EDX
MOV DL, BYTE PTR [EBP + 010H]
ADD EAX, EDX
end;

function FooStdCall(x, y, z: Byte): Integer; stdcall;
asm
// Result = x
XOR EAX, EAX
MOV AL, BYTE PTR [EBP + 008H]
// Result += y
XOR EDX, EDX
MOV DL, BYTE PTR [EBP + 00CH]
ADD EAX, EDX
// Result += z
XOR EDX, EDX
MOV DL, BYTE PTR [EBP + 010H]
ADD EAX, EDX
end;

function FooSafeCall(x, y, z: Byte): Integer; safecall;
asm
// temp = x
XOR EDX, EDX
MOV DL, BYTE PTR [EBP + 008H]
// temp += y
XOR ECX, ECX
MOV CL, BYTE PTR [EBP + 00CH]
ADD EDX, ECX
// temp += z
XOR ECX, ECX
ADD CL, BYTE PTR [EBP + 010H]
ADD EDX, ECX
// Result = temp
MOV EAX, DWORD PTR [EBP + 014H]
MOV DWORD PTR [EAX], EDX
end;</pre>

..

**Nico Bendlin** · 07.10.2002, 00:59

<pre>// Display MessageBox with Result
procedure FooDisplay(Value: Integer); register;
const
Format: PAnsiChar = '%8.8X';
var
Buffer: array [0..8] of AnsiChar;
asm
PUSH Value
MOV EAX, DWORD PTR [Format]
PUSH EAX
LEA EAX, DWORD PTR [Buffer]
PUSH EAX
CALL wsprintfA
ADD ESP, 00000000CH
PUSH 000000000H
PUSH 000000000H
LEA EAX, DWORD PTR [Buffer]
PUSH EAX
PUSH 000000000H
CALL MessageBoxA
end;

procedure Foo();
var
Return: Integer;
asm
// Register
MOV AL, 001H // x
MOV DL, 002H // y
MOV CL, 003H // z
CALL FooRegister // Result in EAX
CALL FooDisplay

// Pascal
PUSH 000000001H // x
PUSH 000000002H // y
PUSH 000000003H // z
CALL FooPascal // Result in EAX
CALL FooDisplay

// CDecl
PUSH 000000003H // z
PUSH 000000002H // y
PUSH 000000001H // x
CALL FooCDecl // Result in EAX
ADD ESP, 00000000CH // Cleanup Stack
CALL FooDisplay

// StdCall
PUSH 000000003H // z
PUSH 000000002H // y
PUSH 000000001H // x
CALL FooStdCall // Result in EAX
CALL FooDisplay

// SafeCall
LEA EAX, DWORD PTR [Return]
PUSH EAX // Offset of Return
PUSH 000000003H // z
PUSH 000000002H // y
PUSH 000000001H // x
CALL FooSafeCall // Result in Return
TEST EAX, EAX // Validate Call
JZ @@SafeCallOk
MOV DWORD PTR [Return], 0FFFFFFFFH
@@SafeCallOk:
MOV EAX, DWORD PTR [Return]
CALL FooDisplay
end;

begin
Foo();
end.</pre>

- nic

**Nico Bendlin** · 07.10.2002, 01:18

Falls Du beim Kompilieren einen "Internal error Cxxxx" bei FooSafeCall bekommst (auch Compiler haben so ihre Probleme mit sich und der Welt

, dann füge bei der Funktion begin/end hinzu.
(nach dem erfolgreichen Kompilieren hat der Compiler plötzlich keine Probleme mehr ohne begin/end, tztztz)

<pre>function FooSafeCall(x, y, z: Byte): Integer; safecall;
begin
asm
// ...
end;
end;</pre>

- nic

**Benjamin Peuthert** · 07.10.2002, 08:07

Vielen Dank!
Jetzt hab ich alles um DIE super schnellen Programme zu entwickeln.

nochmal danke,
b

**Hagen Reddmann** · 07.10.2002, 10:02

Ich habe die Erfahrung gemacht das es besser ist nur die "Endpunkte" eine Algos. in Assembler zu coden. D.h. die eigentlichen inline Assembler Functionen rufen keine weiteren Sub Functionen auf. Man kann zwar versuchen alles in asm zu coden, wird aber dadurch kaum noch Peformancegewinne erzielen. Normalerweise konstruiert man einen Algo. top-down, d.h. seine Komplexit�t nimmt nach unten ab. Nur die innersten Funktionen/Schleifen sollten in inline asm gecodet werden, mehr nicht. 
Superschnelle Programme sind deshalb superschnell weil sie morderne und effiziente Algorithmen nutzen, nicht weil sie in handmade Assembler gecodet wurden. Nat�rlich w�rden diese noch schneller durch asm, aber eben nur zu einem Bruchteil schneller als wenn man den Algorithmus verbessert.

Gru� Hagen

PS: Ausnahmen best�tigen die Regel: Der Delphi Compiler ist sehr ineffizient wenn man nur "Dispatcher" Funktionen mit Parametern ben�tigt. D.h. eine Funktion die auf Grund der Parameter verschiedene andere Funktionen aufruft. In diesem Moment wird der durch den Compiler erzeugte Overhead des Sicherns der Parameter auf dem Stack eigentlich �berfl�ssig und "bremst" aus

**Nico Bendlin** · 09.10.2002, 14:33

Mein Beispiel-Code dient auch mehr als Anschauungsmaterial. 
Dort wo DWORD PTR [EBP + ...] geschrieben wurde, w�rde man normalerweise DWORD PTR [x] schreiben. 

Die einzige Situation, die Assembler zum Aufruf einer Funktion erfordert, ist der Aufruf von __fastcall Funktionen (Microsoft spezifisch). 
Da Delphi __fastcall nicht kennt. Aber mit ein wenig Tricks geht es auch ohne Assembler (siehe Beispiel)...
<pre>program FastCall;

uses
Windows;

// This is an example of an exported __fastcall function (Microsoft Specific).
// #pragma comment(linker, "/EXPORT:FooFastCall=@FooFastCall@12")
// extern "C" signed int __fastcall FooFastCall(
// unsigned char x, // ECX
// unsigned char y, // EDX
// unsigned char z // Stack
// ); // return in EAX

// Swap parameters to map from 'register' to '__fastcall'
// CAVEAT: function declaration differs from original

function FooFastCall_Swapped(_eax, y, x, z: Byte): Integer; register;
external 'FastCall.dll' name 'FooFastCall';

// Write an Wrapper to map from 'register' to '__fastcall'
// CAVEAT: not as fast as in C because of wrapping

// import (for use in ASM blocks only)
procedure _FooFastCall(); register;
external 'FastCall.dll' name 'FooFastCall';

function FooFastCall_Wrapped(x, y, z: Byte): Integer; register;
asm
PUSH ECX // push z
MOV ECX, EAX // x to ECX
// y already in EDX
CALL _FooFastCall
end;

var
Return: Integer;
Buffer: array [0..$20] of AnsiChar;
begin
Return := FooFastCall_Swapped(0, 2, 1, 3);
wvsprintfA(Buffer, 'FastCall(swapped): %8.8X', PAnsiChar(@Return));
MessageBoxA(0, Buffer, 'FastCall', MB_OK);
Return := FooFastCall_Wrapped(1, 2, 3);
wvsprintfA(Buffer, 'FastCall(wrapped): %8.8X', PAnsiChar(@Return));
MessageBoxA(0, Buffer, 'FastCall', MB_OK);
end.</pre>

- nic

Announcement

ASM-Funktion per Inline-Assembler aufrufen.

ASM-Funktion per Inline-Assembler aufrufen.

Comment

Comment

Comment

Comment

Comment

Comment