Delphi und Assembler

[HolgX]

Hallo

Ich weiß nicht, ob das in dieses Forum gehört, aber ein besseres ist mir nicht eingefallen.
Mein Problem war, dass ich mich mit Bit-Operationen befassen mußte, welche bekanntermaßen in Delphi nicht sonderlich unterstützt werden. Also hab ich auf den Assembler zurückgegriffen (mit dem Teil bin ich aufgewachsen), aber leider...

Angeblich sollen alle Anweisungen (laut Borland bis mindestens 386) implementiert sein. Das stimmt so nicht, bis Turbo-Pascal klappte alles reibungslos, aber ich hatte bereits ab Delphi 4 Probleme damit. Nun wollte ich mit Delphi 7 eine Bitvertauschung durchführen (Stichwort Huffman), gabs auch schonmal im Forum, der Code hat mir aber nicht gefallen.
Also selber coden. Folgender Ansatz:

Delphi-Quellcode:

function ReverseBits(Value,Len : integer) : integer;
begin
asm
    mov edx,Value
    mov ecx,Len
    xor eax,eax
@1: shr edx,1
    rcl eax,1
    loop @1
  end;
end;

Prima, Delphi meckert nicht, alles Klasse. Ergebnis: Nur Nullen, buchstäblich. Was heißen soll, daß diese LOOP-Anweisung nicht funktioniert oder anders gesagt, nur der Form halber akzeptiert wird.
Weiter:
Man richte seine Aufmerksamkeit auf die beiden ersten Zeilemn unter "asm". Die habe ich so aus der Delphi-Hilfe übernommen, nur andere Namen verwendet. Wie ich schon sagte, es klappt nicht. Beide Register (EDX und ECX) enthalten immer die gleichen Werte, nämlich den ersten, der im Prozedurkopf steht.

Wenn ich statt dessen das mache, was ich eigentlich nicht wollte (als Assembler-Programmierer *****), funzt es:

Delphi-Quellcode:

function ReverseBits(Value,Len : integer) : integer;
var
 v,l : integer;
begin
  v:=Value;      // das könnte man weglassen und mov edx, value  schreiben
  l:=Len;        // das aber nicht
  asm
    mov edx,v
    mov ecx,l
    xor eax,eax
@1: shr edx,1
    rcl eax,1
    dec cx
    jnz @1        // LOOP funktioniert leider nicht
    mov Result,eax
  end;
end;

Daß diese Assembler-Geschichte nicht zum eigentlichen Bestandteil von Delphi gehort, ist mir schon klar. Aber wenn es schon angeboten wird, sollte es auch funktionieren. Zumal man damit einige Probleme ziemlich einfach erschlagen kann.

Hat jemand schon mal ähnliche Erfahrungen gemacht?

Bis dann, HolgX

[edit=Christian Seehase]Delphi-Tags gesetzt. Bitte künftig selber machen. Danke. Mfg, Christian Seehase[/edit]

[Dax]

Funktioniert

Delphi-Quellcode:

asm
  mov edx, Value
  mov ecx, Len
end;

denn nicht?

BtW: Delphi unterstützt Bitoperaptionen. Stichworte shl, shr, xor, and....

[Christian Seehase]

Moin HolgX,

wie, loop funktioniert nicht?

Delphi-Quellcode:

function ReverseBits(Value,Len : DWORD) : integer;
begin
asm
    mov edx,Value
    mov ecx,Len
    xor eax,eax
@1: shr edx,1
    rcl eax,1
    loop @1
    mov @Result,eax
end;
end;

Wenn Du natürlich Result nicht setzt

[choose]

Hallo HolgX,

schön, dass sich heute noch jemand mit soetwas beschäftigt (sorry, Hagen ). Dein ursprünglicher Entwurf sah dabei etwas gestelzt aus. Verwende asm..end einfach direkt und wisse, wie die Aufrufkonvention in Delphi oder anderen Hochsprachen funktioniert (siehe OH).

Delphi-Quellcode:

function GetReversedBits(AValue, ALen: DWORD): Integer;
asm
    xor  ecx, ecx
    xchg edx, ecx
@1: shr  eax, 1
    rcl  edx, 1
loop @1
    mov  eax, edx
end;

Weiterhin viel Spaß!

[negaH]

Delphi-Quellcode:

function ReverseBits(Value,Len : integer) : integer; 
begin 
asm 
    mov edx,Value 
    mov ecx,Len

1.) das zusätzliche begin end muß raus
2.) Parameter überigt Delphi standardäßig in den Registern EAX,EDX,ECX
3.) ergo: EAX=Value und EDX=Len
4.) mit mov edx, Value -> mov edx,eax und
5.) mit mov ecx, Len -> mov ecx,edx überschreibst du deine Parameter so daß nachfolgender Pseudocode dies verdeutlicht
6.) mov edx, Value; mov ecx, Len; wäre also mov Len, Value; mov ecx, Len

du überschreibst also deine eigenen Parameter !! so kann das nicht funktionieren.

Mein Tipp an dich: vergiß in deiner Situation in Assembler programmieren zu wollen. Der Compiler erzeugt aus reinem PASCAL Code sehr wohl ausreichend guten Assembler.

Delphi-Quellcode:

function GetReversedBits(AValue: Cardinal; ALen: Byte): Cardinal; 
// AValue = EAX; ALen = EDX
asm 
   test edx, edx      
   jz   @Exit        // ALen == 0 ??
   sub  ecx, ecx     // ECX == @Result := 0 
@Start:
   shr  eax, 1       // AValue div 2 
   adc  ecx, ecx     // @Result = @Result + @Result + Ord(previous AValue)
   dec  edx
   jnz  @Start 
   mov  eax, ecx
@Exit:
end;

- shr, shl sind auf heutigen Rechnern langsammer als ADD/ADC/SUB/SBB (Stichworte Pipelines, Instruction Shuffling)
- loop arbeitet nur auf register CX und nicht ECX auf einigen CPU's
- Kombinationen aus dec Register; branch Adresse; sind schneller als der Loop OpCode
- Avalue und @Result sollten Cardinal sein, Integer ist Vorzeichenbehaftet und der OpCode SHR arbeitet ohne Vorzeichen
- ALen sollte der kleinstmögliche Datentyp sein, da theoretisch ALen >= 32 wenig Sinn macht

Gruß Hagen

[HolgX]

Hallo

Also erstmal danke für die Antworten.
Wie ich schon sagte, bin ich sozusagen mit Assembler aufgewachsen, weil es damals (vor ca. 20 Jahren oder so) eben nichts anderes gab. Soll heißen, ich weiß schon, was ich tue. Und was spricht denn dagegen, spezielle Bitoperationen damit zu coden?

Ich antworte hier mal auf alle Posts:
1. Das "begin/end" im ersten Listing ist natürlich Quatsch. Hatte ich auch nicht so.
2. Laut Borland sollte das Ergebnis einer Funktion in EAX übergeben werden, wenn man 1. beachtet. Klappt auch, "Result" ist daher nicht nötig.
3. Parameter -sollen- per Definition in Registern übergeben werden, das funktioniert auch bis D6. Mit meiner D7 Enterprise-Version geht das aber nicht. Das ergänzt sich mit der OH, dort steht, dass EAX, ECX und EDX freie Register sind, also beliebig verwendet werden können (OH-Assmbler). Das Beispiel in der OH sieht auch genauso aus wie mein Listing 1; ich hab dieses Bsp auch mal spaßeshalber eingebaut, funktioniert natürlich auch nicht.
4. LOOP funzt bei mir definiv nicht, es erfolgt immer nur ein Durchlauf, egal welchen Wert CX besitzt (habs kontrolliert). Und ob ECX oder CX - das spielt keine Rolle, da CX immer den niederwertigen Teil besitzt. Um sicherzugehen, hab ich CX explizit mit Werten versorgt, war aber auch nix.

Jedenfalls ist es interessant, daß sich noch Leute dafür interessieren. Ich werd mal mit Hagens Hinweisen weitermachen.

Nochmals danke, HolgX

[Christian Seehase]

Moin HolgX,

Zitat von HolgX:

Mit meiner D7 Enterprise-Version geht das aber nicht.

Ich habe zwar D7 Pro, gehe aber mal davon aus, dass der Compiler der gleiche ist, und bei mir funktioniert loop definitiv.