Der DEC x32 ASM in x64/PurePascal Konvertierungsthread

**Namenloser**

Ich hab zwar keine Ahnung, was eine FPC/XE2 kompatible x64 ABI ist, aber ich habe einfach mal selbst eine PurePascal-Variante für 32-Bit geschrieben:

zusammenfalten · markieren

Delphi-Quellcode:

			type

  TData = packed array[0..7] of LongWord;

procedure Increment8Pure(var Value; Add: LongWord);

var

  HiBits: LongWord;

  Add8: LongWord;

  Data: TData absolute Value;

  Carry: Boolean;

  procedure AddC(var Value: LongWord; const Add: LongWord; var Carry: Boolean); inline;

  begin

    if Carry then

    begin

      Value := Value + 1;

      Carry := (Value = 0); // we might cause another overflow by adding the carry bit

    end

    else

      Carry := False;

    Value := Value + Add;

    Carry := Carry or (Value < Add); // set Carry Flag on overflow

  end;

begin

  HiBits := Add shr 29; // Save most significant 3 bits in case an overflow occurs

  Add8 := Add * 8;

  Carry := False;

  AddC(Data[0], Add8, Carry);

  AddC(Data[1], HiBits, Carry);

  AddC(Data[2], 0, Carry);

  AddC(Data[3], 0, Carry);

  AddC(Data[4], 0, Carry);

  AddC(Data[5], 0, Carry);

  AddC(Data[6], 0, Carry);

  AddC(Data[7], 0, Carry);

  if Carry then

    HashingOverflowError;

end;

Im Anhang befindet sich zur Sicherheit ein Testprogramm, das einige Werte addiert und dabei die Ergebnisse meiner Funktion mit dem Original vergleicht. Es werden ein paar Werte übersprungen („boost“), weil es natürlich im wahrsten Sinne des Wortes ewig dauern würde, alle 2^XXX Werte durchzuiterieren, aber die relevanten Konstellationen sind denke ich abgedeckt. Natürlich besteht meine Funktion den Test, sonst würde ich sie ja nicht hier posten

Wie gesagt ist die Funktion für 32-Bit-Systeme ausgelegt, da ich 1. nur ein 32-Bit-Windows und 2. nur ein 32-Bit-Delphi besitze. Sollte aber kein Problem sein, sie ggf. auf 64 Bit anzupassen.

**jaenicke**

Zitat von NamenLozer:

Wie gesagt ist die Funktion für 32-Bit-Systeme ausgelegt, da ich 1. nur ein 32-Bit-Windows und 2. nur ein 32-Bit-Delphi besitze. Sollte aber kein Problem sein, sie ggf. auf 64 Bit anzupassen.

Sie funktioniert mit XE2 für 64-Bit 1:1 genauso. Zum Vergleich habe ich kurz die Assemblervariante auf 64-Bit umgeschrieben:

zusammenfalten · markieren

Delphi-Quellcode:

			procedure Increment8(var Value; Add: LongWord); assembler;

asm

  MOV EBX,EDX

  LEA EDX,[EDX * 8]

  SHR EBX,29 // 12/13/2011 Fixed

  ADD [ECX].DWord[ 0],EDX

  ADC [ECX].DWord[ 4],EBX

  ADC [ECX].DWord[ 8],0

  ADC [ECX].DWord[12],0

  ADC [ECX].DWord[16],0

  ADC [ECX].DWord[20],0

  ADC [ECX].DWord[24],0

  ADC [ECX].DWord[28],0

  JC HashingOverflowError

end;

Der Test läuft 1:1 durch.

Insgesamt sieht das also so aus mit deiner Variante integriert:

zusammenfalten · markieren

Delphi-Quellcode:

			procedure Increment8(var Value; Add: LongWord); {$IFNDEF PUREPASCAL} assembler; {$ENDIF !PUREPASCAL}

// Value := Value + 8 * Add

// Value is array[0..7] of LongWord

{$IFDEF PUREPASCAL}

var

  HiBits: LongWord;

  Add8: LongWord;

  Data: TData absolute Value;

  Carry: Boolean;

  procedure AddC(var Value: LongWord; const Add: LongWord; var Carry: Boolean); inline;

  begin

    if Carry then

    begin

      Value := Value + 1;

      Carry := (Value = 0); // we might cause another overflow by adding the carry bit

    end

    else

      Carry := False;

    Value := Value + Add;

    Carry := Carry or (Value < Add); // set Carry Flag on overflow

  end;

begin

  HiBits := Add shr 29; // Save most significant 3 bits in case an overflow occurs

  Add8 := Add * 8;

  Carry := False;

  AddC(Data[0], Add8, Carry);

  AddC(Data[1], HiBits, Carry);

  AddC(Data[2], 0, Carry);

  AddC(Data[3], 0, Carry);

  AddC(Data[4], 0, Carry);

  AddC(Data[5], 0, Carry);

  AddC(Data[6], 0, Carry);

  AddC(Data[7], 0, Carry);

  if Carry then

    HashingOverflowError;

end;

{$ELSE !PUREPASCAL}

  {$IFDEF CPUX86}

  asm

    MOV ECX,EDX

    LEA EDX,[EDX * 8]

    SHR ECX,29 // 12/13/2011 Fixed

    ADD [EAX].DWord[ 0],EDX

    ADC [EAX].DWord[ 4],ECX

    ADC [EAX].DWord[ 8],0

    ADC [EAX].DWord[12],0

    ADC [EAX].DWord[16],0

    ADC [EAX].DWord[20],0

    ADC [EAX].DWord[24],0

    ADC [EAX].DWord[28],0

    JC HashingOverflowError

  end;

  {$ENDIF CPUX86}

  {$IFDEF CPUX64}

  asm

    MOV EBX,EDX

    LEA EDX,[EDX * 8]

    SHR EBX,29 // 12/13/2011 Fixed

    ADD [ECX].DWord[ 0],EDX

    ADC [ECX].DWord[ 4],EBX

    ADC [ECX].DWord[ 8],0

    ADC [ECX].DWord[12],0

    ADC [ECX].DWord[16],0

    ADC [ECX].DWord[20],0

    ADC [ECX].DWord[24],0

    ADC [ECX].DWord[28],0

    JC HashingOverflowError

  end;

  {$ENDIF CPUX64}

{$ENDIF !PUREPASCAL}

**himitsu**

Eventuell so?

Die höherbittigen Additionen müssen ja nicht mehr ausgeführt werden, wenn sie nicht nötig sind.
Bin noch etwas müde, aber ich glaube, man kann die beiden IFs auch noch kombinieren, falls nötig.
(also nicht nur über ein billiges OR diese 1-zu-1 zusammenzuhängen)

zusammenfalten · markieren

Delphi-Quellcode:

			{$IFDEF PUREPASCAL}

  function AddV(var Value: LongWord; const Add: LongWord): Boolean; inline;

  var

    Temp: LongWord;

  begin

    Temp := Value;

    Value := Value + Add;

    Result := Value < Temp;

  end;

  function AddC(var Value: LongWord): Boolean; inline;

  begin

    Inc(Value);

    Result := Value = 0;

  end;

var

  Data: TData absolute Value;

begin

  if AddV(Data[0], Add shl 3) and AddC(Data[1]) and AddC(Data[2]) and AddC(Data[3])

      and AddC(Data[4]) and AddC(Data[5]) and AddC(Data[6]) and AddC(Data[7]) then

    HashingOverflowError;

  if AddV(Data[1], Add shr 29) and AddC(Data[2]) and AddC(Data[3])

      and AddC(Data[4]) and AddC(Data[5]) and AddC(Data[6]) and AddC(Data[7]) then

    HashingOverflowError;

end;

{$ELSE !PUREPASCAL}

Natürlich ohne vollständige Auswertung der booleanische Ausdrücke und ohne Überlaufprüfung.

[add]

markieren

Delphi-Quellcode:

			  if ((AddV(Data[0], Add shl 3) and AddC(Data[1])) or AddV(Data[1], Add shr 29)) and AddC(Data[2])

      and AddC(Data[3]) and AddC(Data[4]) and AddC(Data[5]) and AddC(Data[6]) and AddC(Data[7]) then

    HashingOverflowError;

Hoffentlich isses richtig.

Aber für 64 Bit würde ich das auch noch auf 64 Bit umstellen und es so weiter zu verkürzen.

zusammenfalten · markieren

Delphi-Quellcode:

			{$IFDEF PUREPASCAL}

  function AddV(var Value: UInt64; const Add: UInt64): Boolean; inline;

  var

    Temp: UInt64;

  begin

    Temp := Value;

    Value := Value + Add;

    Result := Value < Temp;

  end;

  function AddC(var Value: UInt64): Boolean; inline;

  begin

    Inc(Value);

    Result := Value = 0;

  end;

var

  Data: TData64 absolute Value;  // array[0..3] of UInt64;

begin

  if AddV(Data[0], UInt64(Add) shl 3) and AddC(Data[1]) and AddC(Data[2]) and AddC(Data[3]) then

    HashingOverflowError;

end;

//////////////////////////////////////

{$IFDEF PUREPASCAL}

  function AddC(var Value: UInt64): Boolean; inline;

  begin

    Inc(Value);

    Result := Value = 0;

  end;

var

  Data: TData64 absolute Value; // array[0..3] of UInt64;

  Temp: UInt64;

begin

  Temp := Value;

  Inc(Data[0], UInt64(Add) shl 3);

  if (Value < Temp) and AddC(Data[1]) and AddC(Data[2]) and AddC(Data[3]) then

    HashingOverflowError;

end;

**Assertor**

Hallo,

Wahnsinn! Ihr habt mich gerade wieder daran erinnert, warum ich mich in der DP angemeldet habe

Mit FPC kompatibles x64 ABI (Application Binary Interface) meinte ich Instruktionen, die auch der FPC compiler schluckt, u.U. wegen geänderter Calling Convention. Ob das hier relevant ist, ist eine andere Frage. Leider haben sowohl Delphi als auch FPC so ihre Probleme mit x64 Inline Assembler...

Ich werde das ganze Testen und gebe Feedback, ich sitze noch an den Unittests für die LowLevel (SwapBits etc) und Formatklassen, dann geht es weiter

Zwischenstand zur DEC ist: Was bisher wieder läuft, läuft überall (x32/x64 Delphi, x32 C++ Builder soweit ich es testen kann, FPC x64). Es fehlen noch ein ASM Block im Cipher, sowie die CRCs und Randomfunktionen. Letzteres wird Tricky, weil Hagen mit QueryPerformanceCounter arbeitet - unter FPC oder OSX geht das nicht so gut

Ich stelle hier schonmal die nächste ASM Funktion zur Diskussion und Hijacke damit meinen eigenen Thread:

zusammenfalten · markieren

Delphi-Quellcode:

			{ TODO : Consider implementing IDEAMul() as PurePascal if porting to FPC }

function IDEAMul(X, Y: LongWord): LongWord; assembler;

asm

       AND    EAX,0FFFFh

       JZ     @@1

       AND    EDX,0FFFFh

       JZ     @@1

       MUL    EDX

       MOV    EDX,EAX

       MOV    ECX,EAX

       SHR    EDX,16

       SUB    EAX,EDX

       SUB    CX,AX

       ADC    EAX,0

       RET

@@1:   LEA    EAX,[EAX + EDX - 1]

       NEG    EAX

end;

Ich habe übrigens auch bisher alle Änderungen, Wünsche und validen Bugmeldungen, die im Laufe der letzten 2 Jahre in der DP zur DEC eingegangen sind, verarbeitet. Der Text im ChangeLog hat schon gut 22 Lines von großen Änderungen.

Jetzt erstmal Kaffee...

Gruß
Assertor

**jbg**

Zitat von Assertor:

Ich stelle hier schonmal die nächste ASM Funktion zur Diskussion und Hijacke damit meinen eigenen Thread:

zusammenfalten · markieren

Delphi-Quellcode:

			{ TODO : Consider implementing IDEAMul() as PurePascal if porting to FPC }

function IDEAMul(X, Y: LongWord): LongWord; assembler;

asm

       AND    EAX,0FFFFh

       JZ     @@1

       AND    EDX,0FFFFh

       JZ     @@1

       MUL    EDX

       MOV    EDX,EAX

       MOV    ECX,EAX

       SHR    EDX,16

       SUB    EAX,EDX

       SUB    CX,AX

       ADC    EAX,0

       RET

@@1:   LEA    EAX,[EAX + EDX - 1]

       NEG    EAX

end;

Hier die Win64 kompatible Version. Ein "MOV EAX,ECX" das den ersten Parameter in EAX kopiert, reicht aus und alles läuft wie gewohnt weiter.

zusammenfalten · markieren

Delphi-Quellcode:

			function IDEAMul(X, Y: LongWord): LongWord; assembler;

asm

{$IFDEF CPUX64}

       MOV EAX,ECX

{$ENDIF CPUX64}

       AND EAX,0FFFFh

       JZ @@1

       AND EDX,0FFFFh

       JZ @@1

       MUL EDX

       MOV EDX,EAX

       MOV ECX,EAX

       SHR EDX,16

       SUB EAX,EDX

       SUB CX,AX

       ADC EAX,0

       RET

@@1: LEA EAX,[EAX + EDX - 1]

       NEG EAX

end;

UPDATE:
Und hier die PurePascal Version:

zusammenfalten · markieren

Delphi-Quellcode:

			function IDEAMul(X, Y: LongWord): LongWord;

begin

  X := X and $FFFF;

  if X <> 0 then

  begin

    Y := Y and $FFFF;

    if Y <> 0 then

    begin

      X := X * Y;

      Result := X - (X shr 16);

      if Word(X) < Word(Result) then // carry flag check for "sub cx,ax"

        Inc(Result);

      Exit;

    end;

  end;

  Result := -(X + Y - 1);

end;

**jbg**

Zitat von jaenicke:

zusammenfalten · markieren

Delphi-Quellcode:

			procedure Increment8(var Value; Add: LongWord); assembler;

asm

  MOV EBX,EDX

  LEA EDX,[EDX * 8]

  SHR EBX,29 // 12/13/2011 Fixed

  ADD [ECX].DWord[ 0],EDX

  ADC [ECX].DWord[ 4],EBX

  ADC [ECX].DWord[ 8],0

  ADC [ECX].DWord[12],0

  ADC [ECX].DWord[16],0

  ADC [ECX].DWord[20],0

  ADC [ECX].DWord[24],0

  ADC [ECX].DWord[28],0

  JC HashingOverflowError

end;

Das "assembler" ist in Delphi nicht mehr notwendig und wird nur zur Abwärtskompatibilität zu Turbo Pascal unterstützt.
Ein [ECX] reicht nicht aus, da dadurch nur auf Speicher in den ersten 4 GB zugegriffen werden kann. Der Addressraum unter x64 aber um einiges größer ist. Also muss [RCX] benutzt werden.
Du zerstörst das non-volatile RBX Register. Da hat man nun so viele "Freiwild" Register und du nimmst gerade eines, dass beim Rücksprung wieder seinen originalen Inhalt haben muss.
Also am besten RBX durch EAX, R9D, R10D oder R11D ersetzen.
Ob das "JC HashingOverflowError" so gut mit der strikten Aufrufkonvention unter x64 vereinbar ist, kann ich jetzt nicht beurteilen, da ich den Code des Sprungziels nicht kenne.

Und wenn man schon 64bit Assembler hat kann man den auch gleich verwenden:

markieren

Delphi-Quellcode:

			procedure Increment8(var Value; Add: LongWord);

asm

  SHL RDX, 3 // the caller writes to EDX what automatically clears the high DWORD of RDX

  ADD QWORD PTR [RCX     ], RDX

  ADC QWORD PTR [RCX +  8], 0

  ADC QWORD PTR [RCX + 16], 0

  ADC QWORD PTR [RCX + 24], 0

  JC HashingOverflowError

end;

**himitsu**

Zitat von jbg:

the caller writes to EDX what automatically clears the high DWORD of RDX

Und das ist auch immer definitiv so?
Nja, ein kleiner zusätzlicher Befehl, um das zu leeren/sicherzustellen, sollte auch nicht so sehr stören.

Für eine zukünftig unbestimmte Portierungen auf weitere Systeme/CPUs wäre jeweils eine (zusätzliche) PurePascal-Variante bestimmt kein Nachteil.

**jbg**

Zitat von himitsu:

Zitat von jbg:

the caller writes to EDX what automatically clears the high DWORD of RDX

Und das ist auch immer definitiv so?

Ja, da der Prozessor bei einem "MOV EDX, xyz" immer das obere QWORD ablöscht (steht auch so in der x64 Instruction Set Beschreibung) und zudem die Win64 Calling Convention es vorschreibt den zweiten Parameter im RDX Register zu übergeben. Da steht nichts von EDX sondern RDX, also alle Bits.

Zitat:

Für eine zukünftig unbestimmte Portierungen auf weitere Systeme/CPUs wäre jeweils eine (zusätzliche) PurePascal-Variante bestimmt kein Nachteil.

Portabel ist der x64-Assembler Code natürlich nicht. Der ist speziell für Win64 geschrieben. Nur mit PurePascal bist du platformunabhängig.

**Assertor**

Nice, Andreas

Zitat von jbg:

Ob das "JC HashingOverflowError" so gut mit der strikten Aufrufkonvention unter x64 vereinbar ist, kann ich jetzt nicht beurteilen, da ich den Code des Sprungziels nicht kenne.

markieren

Delphi-Quellcode:

			procedure HashingOverflowError;

begin

  raise EDECHashException.CreateRes(@sHashingOverflowError);

end;

Sollte imo also kein Problem sein.

Zitat von jbg:

Und wenn man schon 64bit Assembler hat kann man den auch gleich verwenden:

markieren

Delphi-Quellcode:

			procedure Increment8(var Value; Add: LongWord);

asm

  SHL RDX, 3 // the caller writes to EDX what automatically clears the high DWORD of RDX

  ADD QWORD PTR [RCX     ], RDX

  ADC QWORD PTR [RCX +  8], 0

  ADC QWORD PTR [RCX + 16], 0

  ADC QWORD PTR [RCX + 24], 0

  JC HashingOverflowError

end;

Das läuft in x64 Delphi, das RDX Register scheint dem FPC x64 Compiler aber nicht zu gefallen:

Zitat:

Error: Unknown identifier "RDX"

Gleich in der ersten Zeile bei SHL RDX, 3.

Nun gut, ich kenne FPC nicht weiter, möglicherweise ist dies bekannt und über Defines steuerbar. Ggf bleibt dort der Weg über PurePascal, was wegen der breiteren Unterstützung ja mit o.g. Delphi Code möglich ist.

Übrig sind noch gut 9 Assembler Funktionen, bis zur Lauffähigkeit. Wenn keine Einwände bestehen, würde ich diese gerne ebenfalls in diesem Thread zur Diskussion stellen.

@Andreas: Gerade schon ein Ping für Dein IDEAMul Post bekommen. Wow, Du bist schnell

Gruß
Assertor

P.S: Das wird eine lange Namensliste im ChangeLog - Attribution to Himitsu, Jaenicke, jbg, NamenLozer (alphabetisch)

**Assertor**

So, weiter geht es (*):

zusammenfalten · markieren

Delphi-Quellcode:

			function DoRndBuffer(Seed: Cardinal; var Buffer; Size: Integer): Cardinal; assembler;

// comparable to Borlands Random() function

asm

      AND     EDX,EDX

      JZ      @@2

      AND     ECX,ECX

      JLE     @@2

      PUSH    EBX

@@1:  IMUL    EAX,EAX,08088405H // 134775813

      INC     EAX

      MOV     EBX,EAX

      SHR     EBX,24

      MOV     [EDX],BL

      INC     EDX

      DEC     ECX

      JNZ     @@1

      POP     EBX

@@2:

end;

function RandomSystemTime: Cardinal; assembler;

// create Seed from Systemtime and PerformanceCounter

var

  SysTime: record

    Year: Word;

    Month: Word;

    DayOfWeek: Word;

    Day: Word;

    Hour: Word;

    Minute: Word;

    Second: Word;

    MilliSeconds: Word;

    Reserved: array [0..7] of Byte;

  end;

  Counter: record

    Lo,

    Hi: Integer;

  end;

asm

      LEA     EAX,SysTime

      PUSH    EAX

      CALL    GetSystemTime

      MOVZX   EAX,Word Ptr SysTime.Hour

      IMUL    EAX,60

      ADD     AX,SysTime.Minute

      IMUL    EAX,60

      MOVZX   ECX,Word Ptr SysTime.Second

      ADD     EAX,ECX

      IMUL    EAX,1000

      MOV     CX,SysTime.MilliSeconds

      ADD     EAX,ECX

      PUSH    EAX

      LEA     EAX,Counter

      PUSH    EAX

      CALL    QueryPerformanceCounter

      POP     EAX

      ADD     EAX,Counter.Hi

      ADC     EAX,Counter.Lo

end;

Bei RandomSystemTime wird es tricky: QueryPerformanceCounter in RandomSystemTime ist natürlich ein No-Go für Crossplatform, also bleibt nur PurePascal.

Kennt da jemand was, was auch FPC versteht? Wie gesagt, ich arbeite nicht mit FPC, das hier ist nur für die Vielen, die danach fragen... Ich muß erstmal die RTL von XE2 durchsuchen, ob es eine Win/OSX Kapselung gibt.

Falls sich jemand fragt, wie viel noch kommt: die CRC Funktionen (5 an der Zahl).

@Himitsu: Hattest Du nicht schonmal LHSZ für FPC bzw. x64 portiert? Ich meine mich da an irgendwas zu erinnern...

Ihr seid klasse Während hier Code gepostet wird, kann ich schon an anderer Stelle weitermachen - so könnte die DEC 6.0 wirklich was werden!

Gruß
Assertor

(*) Kein Edit, für die Benachrichtigung - Andreas hat ja gerade einen Lauf