[ASM] While-Schleife tut was sie will

[glkgereon]

Hi,

Ich spiele gerade was mit dem Delphi-Inline-Assembler rum (Mit der Absicht dann irgendwann einen anderen Quellcode etwas optimieren zu können.

Ich habe mir einfach mal folgenden Code genommen:

Delphi-Quellcode:

begin
  Akt:=0;
  while Akt<>5 do
  begin
    if Random(2)=1 then Inc(Akt);
  end;
  Memo1.Lines.Add(IntToStr(Akt));  
end;

das ist zwar ziemlich Sinnfrei...aber egal

Also ab in ASM damit...

Code:

procedure Add(I: Integer);
begin
  Form1.Memo1.Lines.Add(IntToStr(I));
end;

function Rand(N: Integer): Integer;
begin //Hier hatte ich ein Problem mit dem Optionalen Parameter...
  Result:=Random(N);
end;

asm
  MOV EDX,0 //Erstmal nullen

  @start: //Schleifenanfang
  CMP EDX,5 //Ist es 5?
  JE @ende //JMP ende

  MOV EAX,2 //1. Param für Rand
  CALL Rand //Rand Callen
  CMP EAX,1 //ist Ergebnis 1?
  JE @doinc //Dann JMP doinc
  JMP @endeinnen //Sonst JMP schleifenende

  @doinc: //doinc
  ADD EDX,1 //EDX erhöhen

  @endeinnen: //Schleife zuende
  JMP @start //Zum Schleifenanfang

  @ende: //Am Ende
  CALL Add //Add Callen
end;

Was nun passiert ist folgendes (Haltepunkte...)
+ 0 nach EDX
+ übergeht JE @ende
+ 2 nach EAX
+ Call Rand
Aber dann, bei JE @doinc springt er auf einmal nach CMP EDX,5
Und das versteh ich überhaupt nicht....

kann mir da mal irgendwer auf die Sprünge helfen? (im wahrsten sinne des wortes^^)

[sirius]

"call system.@RandInt"

Dann kannst du dir deine Zwischenfunktion sparen.

[glkgereon]

Zitat von sirius:

"call system.@RandInt"

Dann kannst du dir deine Zwischenfunktion sparen.

Öhm, das gibt es bei mir nicht
D2k5 Pers...

BTW: Es scheint so als würde Delphi einfach bei jumps nicht anhalten, oder?

aber jetzt wird EDX regemäßig geleert :-/
Immer beim Aufruf von Rand...

[sirius]

Zitat von glkgereon:

Zitat von sirius:

"call system.@RandInt"

Dann kannst du dir deine Zwischenfunktion sparen.

Öhm, das gibt es bei mir nicht
D2k5 Pers...

BTW: Es scheint so als würde Delphi einfach bei jumps nicht anhalten, oder?

aber jetzt wird EDX regemäßig geleert :-/
Immer beim Aufruf von Rand...

Klar, das gibts schon immer, z.B. in Delphi 7

Tja, macht Delphi etwa auch bei IASM Code-Optimierung? Drück doch mal Strg+Alt+C beim Debuggen und schau mal, ob sich etwas geändert hat

Und schau mal hier den vorletzten Beitrag

[Neutral General]

Zitat von glkgereon:

aber jetzt wird EDX regemäßig geleert :-/
Immer beim Aufruf von Rand...

Das hab ich auch grad festgestellt.. wahrscheinlich schreibt rand,bzw random was ins edx rein.. benutz doch mal ecx...

Bei mir siehts jetzt so aus:

Delphi-Quellcode:

procedure KA;
asm
         mov ecx,0
         cmp ecx,5
         je @end
  @loop: mov eax,2
         call rand
         cmp eax,1
         jne @loop
         inc ecx
         cmp ecx,5
         jne @loop
         mov eax,ecx
         call Add
  @end:  ret
end;

[glkgereon]

Zitat von sirius:

Klar, das gibts schon immer, z.B. in Delphi 7

Meins kennt das aber nicht

Zitat von sirius:

Tja, macht Delphi etwa auch bei IASM Code-Optimierung? Drück doch mal Strg+Alt+C beim Debuggen und schau mal, ob sich etwas geändert hat

Und schau mal hier den vorletzten Beitrag

Im CPU-Fenster steht der selbe ASM-Code wie im Code.
gut, 1 und 5 sind nun $01 und $05 usw, aber der rest is gleich

den forenpost guck ich grad

[glkgereon]

Zitat von Neutral General:

Zitat von glkgereon:

aber jetzt wird EDX regemäßig geleert :-/
Immer beim Aufruf von Rand...

Das hab ich auch grad festgestellt.. wahrscheinlich schreibt rand,bzw random was ins edx rein.. benutz doch mal ecx...

Könnte man nicht auch einfach PUSH EDX und POP EDX nehmen?

*quellcode vergleich*

[Cöster]

Zitat von glkgereon:

Aber dann, bei JE @doinc springt er auf einmal nach CMP EDX,5

Ich nehme an, dass

Delphi-Quellcode:

JE @doinc
JMP @endeinnen
{...}
@endeinnen:
JMP @start

durch
JNE @Start o.ä. optimiert wird.

[glkgereon]

Hurra
Ich habe das ganze noch etwas erweitert...

Delphi-Quellcode:

begin 
  Akt:=0; 
  Cnt:=0;
  while Akt<>5 do 
  begin 
    if Random(2)=1 then Inc(Akt); 
    Inc(Cnt);
  end; 
  Memo1.Lines.Add(IntToStr(CNt));  
end;

Delphi-Quellcode:

procedure Add(I: Integer);
begin
  Form1.Memo1.Lines.Add(IntToStr(I));
end;

function Rand(N: Integer): Integer;
begin
  Result:=Random(N);
end;

procedure Gen;
begin
  asm
    MOV EBX,0
    MOV ECX,0

    @start:
    CMP EBX,5
    JE @ende

    ADD ECX,1

    PUSH EBX
    PUSH ECX
    MOV EAX,2
    CALL Rand
    POP ECX
    POP EBX

    CMP EAX,1
    JNE @start

    ADD EBX,1
    JMP @start

    @ende:
    MOV EAX,ECX
    CALL Add
  end;
end;

und es tut!

auf zum nächsten (mehr oder weniger sinnlosen) asm-projekt

[sirius]

Zitat von Neutral General:

Das hab ich auch grad festgestellt.. wahrscheinlich schreibt rand,bzw random was ins edx rein.. benutz doch mal ecx...

Ja richtig, randint benutzt edx.
Da muss man auch aufpassen. In Delphi ist es o, dass alle Register AUSSER EAX, ECX und EDX nach dem Funktionsaufruf gleich sind. Aber diese 3 Register solltest du selber sichern. Häufig missbraucht Delphi ESI zum zählen.