Assembler-Rätsel

[TurboMagic]

Schreib doch einfach Mal ein paar Unit Tests dafür, dann wirst du schon ein Gefühl dafür bekommen ob das soweit alles abdeckt. DUnit/DUnit2 sind deine Freunde...

[himitsu]

Bin auch grade bissl raus, aus'm ASM.
Es gibt ja ein paar Register, die man sichern muss, bzw. da man nicht verändern darf.

Wobei mir grade nicht einfällt wofür EBX war, (glaub Fehlerbehandlung, Stackverwaltung oder so)
im Windows x86 ... für x64 und andere Plattformen bissl anders.

Dank Multiplatform versuch ich wieder möglichst viel in Pascal zu machen, vor allem da eine meiner letzten Assenbler-Optimierungen auf modernen Intel-CPU gegen deren Optimierung arbeitete und mein hochoptimiertes Assembler wesentlich langsamer war, als das was Delphi aus dem Pascal machte.


Hier gibt's auch noch bissl was in der OH zu finden.
http://docwiki.embarcadero.com/RADSt...bly_Code_Index

Zitat von aus Verwendung des integrierten Assemblers:

In einer asm-Anweisung muss der Inhalt der Register EDI, ESI, ESP, EBP und EBX erhalten bleiben

Auch dazu, was Delphi in den Pascal-Funktionen am Anfang einfügt und wann/warum.

Zitat von aus Assembler-Prozeduren und -Funktionen:

Code:

PUSH   EBP         ;Present if Locals <> 0 or Params <> 0
MOV    EBP,ESP         ;Present if Locals <> 0 or Params <> 0
SUB    ESP,Locals      ;Present if Locals <> 0
; &#8230;
MOV    ESP,EBP         ;Present if Locals <> 0
POP    EBP         ;Present if Locals <> 0 or Params <> 0
RET    Params          ;Always present

Aber mit Conditional-Expressions kommt man IMHO sowieso oft besser.

Zitat:

Delphi-Quellcode:

asm
  ...
end;
{$ELSE !CPUX86}
  {MESSAGE Fatal 'not implemented'}
{$ENDIF !CPUX86}
{$ENDIF !PUREPASCAL}

Delphi-Quellcode:

{$IF Defined(PUREPASCAL)}
begin
  ...
end;
{$ELSEIF Defined(CPUX86)}
asm
  ...
end;
{$ELSE}
  {MESSAGE Fatal 'not implemented'}
{$IFEND}

Hier kann man auch schöner Verschachteln und Zusammenfassen, ohne wirklich in X Ebenen zu verschachteln, wie z.B. {$IF Defined(AAA) OR Defined(BBB)} .

[Hobbycoder]

Vor langer, langer Zeit habe ich im Zuge meiner Lehre damals auch mit Assembler programmieren müssen. Das war auf eineM 8008 (kann auch ein anderer gewesen sein), und das ganze mit einem Programmierkoffer (hatte 4 KB Speicher, 8 LEDs, 8 Schalter, 8stellige 7-Segment-Anzeige und einen Hexa-Nummernblock). Zuhause habe ich dann auf meinem C64 noch einige Sachen in Assembler gemacht, nur so aus Spaß.
Das war allerdings noch recht einfach, weil man nahezu alles direkt Addressieren konnte, Bildschirmspeicher, RAM etc.
Danach habe ich mich nie wieder damit beschäftigt.

Mittlerweile hat sich natürlich viel verändert, und mit meinem damaligen Basiswissen kann ich heute nicht mehr viel anfangen, selbst wenn ich meine Unterlagen aus der Lehre wieder ausgrabe.

Daher meine Frage: könnt ihr gute Dokus, Tutorials oder Bücher empfehlen, um sich in dieses Thema wieder etwas einzuarbeiten, wo auch auf die Besonderheiten, die gegenüber der früheren Architektur, heute unter Windows eingegangen wird. Ich will damit natürlich jetzt nicht groß was machen, aber es würde mich schon interessieren in dem Bereich mein Wissen etwas aufzufrischen, und auch mal auszuprobieren, ob ich das heute noch verstehen würde. Wie gesagt, ist halt schon ewig her.

[samso]

@Maekkelrajter: Du solltest den Fall limit<0 noch abfangen.

@Hobbycoder: Nichts für ungut, aber hättest Du nicht ein eigenes Thema aufmachen können?

[Maekkelrajter]

Zitat von samso:

@Maekkelrajter: Du solltest den Fall limit<0 noch abfangen.

Darauf hatte ich verzichtet, da weiter unten im Code der Vergleich des Substr mit dem zu durchsuchenden Teilstring durchgeführt wird:

Delphi-Quellcode:

      
       mov   ebx, [eax-4]  //Length(Substr)
       sub   esi, ecx      //effective length of Str (= length(str) - offset)
       add   edx, ecx      //addr of the first AnsiChar at starting position
       cmp   esi, ebx
       jl    @Past         //jump if EffectiveLength(Str)<Length(Substr)
       
       [...]
@Past:
       pop   ebx
       pop   esi
@Nil:
       xor   eax, eax
       jmp  @done

Falls 'EffectiveLength(Str) < Length(Substr)', was bei negativem 'Limit' der Fall wäre, erfolgt der Ausstieg mit Result =0.
Die von dir vorgeschlagene Variante hätte zur Folge, dass auch bei allen Limit-Werten < 0 der limit-Wert einfach ignoriert wird und die Suche dennoch durchgeführt wird.
Deshalb habe ich das ganze Design noch einmal überarbeitet. Die Vorbelegung der Parameter wurde entfernt, ebenso die Null-Prüfung von 'Limit'. Alle Limit-Werte, die kleiner oder gleich Offset sind führen jetzt zu einem Ende mit Result = 0, ebenso wenn Offset kleiner 1 ist.
Für den geplanten speziellen Einsatz dieser Funktion ist das so völlig ausreichend:

Delphi-Quellcode:

      

function PosInLimits(const SubStr, Str: RawByteString; Offset,Limit:Integer): Integer;
asm
       test  eax, eax
       jz    @Nil
       test  edx, edx
       jz    @Nil
       dec   ecx
       jl    @Nil

       push  esi
       push  ebx

       mov   esi, [edx-4]        //Length(Str)

       mov   ebx, limit          // limit holen
       cmp   ebx, esi            // limit >= Length(Str)?
       jge   @IgnoreLimit        // limit ignorieren
       mov   esi, ebx            // limit übernehmen anstelle von Length(Str)
@IgnoreLimit:

       mov   ebx, [eax-4]        //Length(Substr)
       sub   esi, ecx            //effective length of Str (= length(str) - offset)
       add   edx, ecx            //addr of the first AnsiChar at starting position
       cmp   esi, ebx
       jl    @Past               //jump if EffectiveLength(Str)<Length(Substr)

       [usw.]

Trotzdem Danke für den Hinweis!

Gruß LP