Hi Osterhasis!

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:

zusammenfalten · markieren

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:

zusammenfalten · markieren

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


\\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?

markieren

Delphi-Quellcode:

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

ich glaub's net... das ist einfach zu einfach

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...

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

dizzy

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

zusammenfalten · markieren

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 von Delphi:

"Ungültige Kombination von Opcode und Operanden"

beim

markieren

Code:

fsubp st(1);

Auch mit einem:

markieren

Code:

fsubp qword ptr st(1);

passiert dies.

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

Danke schonmal nochmals ,
dizzy

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

Danke nochmals!
dizzy

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

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

Guts Oster-Nächtle,
dizzy