[inline-asm] Ich komm mit den Parametern net klar...

[dizzy]

Hi Osterhasis! :stupid:

Ich spiele wieder ein wenig mit dem Inline-Assembler herum, und hab mir dazu auch mal die D7-Sprachreferenz + Handbuch vor die Nase gelegt. Aber die gehen ja leider leider kaum auf den Assembler ein :(

Folgende Methoden funktionieren wie gewünscht:

Delphi-Quellcode:

type
  TQuat = record
    x,y,z,w: double;
  end;
.
.
.
function addQ(const a, b: TQuat): TQuat;
asm
  FLD  QWORD PTR [EBP-32]; // a.x to stack
  FLD  QWORD PTR [EBP-24]; // a.y to stack
  FLD  QWORD PTR [EBP-16]; // a.z to stack
  FLD  QWORD PTR [EBP- 8]; // a.w to stack

  FADD QWORD PTR [EBP-40]; // result.w := a.w + b.w
  FSTP QWORD PTR [ECX+24];
  FADD QWORD PTR [EBP-48]; // result.z := a.z + b.z
  FSTP QWORD PTR [ECX+16];
  FADD QWORD PTR [EBP-56]; // result.y := a.y + b.y
  FSTP QWORD PTR [ECX+ 8];
  FADD QWORD PTR [EBP-64]; // result.x := a.x + b.x
  FSTP QWORD PTR [ECX   ];
end;

function mulQ(const a, b: TQuat): TQuat;
asm
  FLD  QWORD PTR [EBP-32]; // a.x to stack
  FLD  QWORD PTR [EBP-24]; // a.y to stack
  FLD  QWORD PTR [EBP-16]; // a.z to stack
  FLD  QWORD PTR [EBP- 8]; // a.w to stack

  FMUL QWORD PTR [EBP-40]; // result.w := a.w * b.w
  FSTP QWORD PTR [ECX+24];
  FMUL QWORD PTR [EBP-48]; // result.z := a.z * b.z
  FSTP QWORD PTR [ECX+16];
  FMUL QWORD PTR [EBP-56]; // result.y := a.y * b.y
  FSTP QWORD PTR [ECX+ 8];
  FMUL QWORD PTR [EBP-64]; // result.x := a.x * b.x
  FSTP QWORD PTR [ECX   ];
end;

Das ist ja schonmal ein Anfang! (Geht's nebenbei noch eleganter/schneller??)
Aaaber, nun hab ich eine Prozedur, die nur einen Parameter bekommt, und schon klappt es nicht mehr. Die Prozedur:

Delphi-Quellcode:

function sqrQ(const a: TQuat): TQuat;
asm
  FLD  QWORD PTR [EBP-32];
  FLD  QWORD PTR [EBP-24];
  FLD  QWORD PTR [EBP-16];
  FLD  QWORD PTR [EBP- 8];

  FMUL QWORD PTR [EBP- 8];
  FSTP QWORD PTR [ECX+24]; // *
  FMUL QWORD PTR [EBP-16];
  FSTP QWORD PTR [ECX+16];
  FMUL QWORD PTR [EBP-24];
  FSTP QWORD PTR [ECX+ 8];
  FMUL QWORD PTR [EBP-32];
  FSTP QWORD PTR [ECX   ];
end;

Ich hab sie genau so aufgebaut wie die anderen beiden, aber folgende Fehlermeldung zur Runtime:
[...] Accessviolation [...] Schreiben von Adresse 00000018
An der mit nem * markierten Zeile wird gehalten.

Was kann/muss ich anders machen? Ich verstehe die Übergabe von nicht-ordinalen Typen an ein function-result nicht so wirklich...


Großes Osterdanke schonmal!
dizzy :thuimb:


\\edit: Nachtrag: Wäre es evtl. sinnvoll hierfür MMX einzusetzen? (Es geht geschwindigkeitstechnisch um die Wurst ;) ) Wie würde man das dann implementieren müssen?

[negaH]

Delphi-Quellcode:

function addQ(const a, b: TQuat): TQuat;
asm
  fld  a.x
  fld  qword ptr a.y
...

[dizzy]

:love: ich glaub's net... das ist einfach zu einfach :wall:

Also ist das result-register abhähgig von der Parameteranzahl? Weil in den 2 oberen Prozeduren von mir steht die Adresse des Results in ECX, bei der neuen "sqrQ", die ich so gebaut hab wie du sagtest, kommt das Ergebnis nach EBX (laut CPU-Fenster). Und beim neuen "sqrQ" steht der Parameter tatsächlich in EAX! Bei den beiden oberen bin ich mit EBP dran gegangen, weil es der Compiler auch tat als ich die Prozedur ohne asm geschrieben hab, um zu sehen wie der Compiler es macht... :gruebel:

Aber wurscht! Soll mir alles Recht sein, denn es läuft :thuimb:
Danke nochmals!

dizzy

[dizzy]

Hm, noch eine kleine Frage dazu:
Der Compiler macht folgendes:

Delphi-Quellcode:

function mulQ(const a, b: TQuat): TQuat;
asm
.
.
  // a.x*b.x - a.y*b.y
  fld  a.x;
  fmul b.x;
  fld  a.y;
  fmul b.y;
  fsubp st(1);
.
.

Wenn ich das allerdings so machen möchte, so bekomme ich zur Compiletime die Fehlermeldung:

Zitat:

Zitat von Delphi

"Ungültige Kombination von Opcode und Operanden"

beim

Code:

fsubp st(1);

Auch mit einem:

Code:

fsubp qword ptr st(1);

passiert dies.

Kann ich selber nicht indiziert auf den FPU-Stack zugreifen?

Danke schonmal nochmals :),
dizzy

[dizzy]

:duck: push...

Ich finde dazu einfach NIX. Scheint wohl niemand mehr eine FPU zu assemblieren.
Noch mal so zur Info: Ich habe eine Formel (die in Kommentar) in DL in einer Funktion geschrieben, und mir dann zur Runtime das im CPU-Fenster beguckt, und einfach genau das abgeschrieben, was der Compiler draus gemacht hat. Nun, und das geht wohl nicht :?

Muss da noch ein Typecast hin (welcher)? Geht das so garnicht? Ich bin mir sicher, es ist nur eine Kleinigkeit, die sooo unbedeutend ist, dass es niemand aufschreibt, und ich bin zu blöd es herauszubekommen :roll:

Danke nochmals!
dizzy

[Christian Seehase]

Moin Dizzy,

auch wenn's für den Inline Assembler zuviel an Informationen ist, könntest Du Dir mal bei Intel passende Dokumentationen herunterladen.
Für den Befehlssatz des P4 wären das die 245470-011 (Basic Architecture), 245471-011 (Instruction Set Reference) und 245472-011 (System Programming Guide).

FSUBP kannst Du auf zwei Arten verwenden:

FSUBP
entspricht ST(1) := ST(1) - ST(0), pop register stack

oder

FSUBP ST(I),ST(0)
entspricht ST(I) := ST(I) - ST(0), pop register stack

[dizzy]

:wall: hab doch gesagt, dass es bestimmt ganz einfach ist :)

Und ich nehme jetzt mal an, dass fsubrp die Reihenfolge von st(1)-st(0) zu st(0)-st(1) verkehrt behandelt, gell!?
Ich danke dir ganz kräftig! Jetzt sind meine Funktionen teilw. 3x so schnell wie vorher! Goil
Auch danke für den Tip mit der Lektüre! Wird umgehend gesaugt/beäugt. So laaangsam blicke ich die Sache mit Assembler. Gaaanz langsam :mrgreen:

Guts Oster-Nächtle,
dizzy