XProfan X4 mit Inlineassembler und mehr

  • Wie an anderer Stelle schon erwähnt, bastele ich derzeit an einen Inline-Assembler für XProfan X4. Bis zur offiziellen Subscription dauert es noch eine Weile, aber im Interpreter funktioniert der Inline-Assembler bereits. Und damit die Wartezeit bis zur Subscription nicht lang wird, gibt es den Interpreter PROFAN.EXE schon hier für alle zum kostenlosen Download:

    xprofan.de/download/XProfanX4alpha.zip

    Viel Spaß beim Ausprobieren. Einige Quellcodes liegen bei und werden hier im Thread von mir vorgestellt.

    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

    2 Mal editiert, zuletzt von RGH (25. März 2017 um 00:29)

    • Anzeige

    Hallo!

    Wenn du gerade an deiner Website arbeitest oder dein aktuelles Hosting überdenkst: Wir betreiben mit NetzLiving eine Hosting-Plattform, die speziell auf Performance, Sicherheit und einfache Verwaltung ausgelegt ist.

    • ✔️ Schnelle Ladezeiten (optimiert für WordPress, WoltLab & Co.)
    • ✔️ Deutsche Server & DSGVO-konform
    • ✔️ Persönlicher Support (kein 0815-Ticket-System)

    Mehr erfahren

  • Ein erste Minimal-Assembler-Programm zum Addieren zweier Zahlen:


    Die Zahl hinter dem Funktionsnamen gibt die Anzahl der Parameter an. Diese ist wichtig, damit nach dem Aufruf korrekt "aufgeräumt" wird. Im Debug-Modus, der derzeit im Interpreter noch fix eingestellt ist, wird ein Assemblerlisting für jede ASM-Funktion ausgegeben. Der Dateiname ist der Funktionsname mit der Endung "lst". Dieses Listing sieht hioer so aus:


    Das zwingend notwendige "PUSH EBP" und "MOV EBP,ESP" am Anfang, sowie das "MOV ESP,EBP" und "POP EBP" und das "RET x" fügt XProfan selbsttätig hinzu. Vom ESP-Register (Stack) sollte man auf alle Fälle im Code die Finger lassen!

    Par1 steht für [ebp + 8] (die Speicherstelle an der der erste Parameter abgelegt wird), Par2 für [ebp + 12], etc. Da wir uns in der 32-Bit-Welt befinden hat jeder Parameter eben 4 Byte! Der Wert in EAX ist der Rückgabewert der Funktion.

    Der ASM-Befehl assembliert den nachfolgenden Code bis ENDASM und fügt die Funktion der Liste der importierten Funktionen bei, so wie es auch ImportDLL und ImportFunc machen. Anschließend steht die Funktion dem Programm zur Verfügung.

    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Und hier ein etwas komplexeres Beispiel mit Sprüngen und Strings direkt aus dem XProfan-Quellcode (Verschlüsselungsroutine, basierend auf einem Assemblercode von Frank Abbing):

    Die vier PUSH un POP am Anfnag/Ende kann man auch weglassen. Beim Delphi-Inline-Assembler sind sie empfehlenswert, da Delphi die Register auch zur Parameterübergabe nutzt. Die "@@" bei den Labels kann man auch weglassen. Ich habe den Teil eben einfach aus meinem Delphicode kopiert und lediglich "Par1" und "Par2" eingesetzt.

    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Und auch die Windows-API kann genutzt werden. Drei unterschiedliche Beispiele mit gleichem Ergebnis:

    Es geht auch mit weniger verschwenderischem Registerverbrauch:

    Und ein erstes Makro "FCALL" erlaubt den direkten Aufruf aller mit ImportFunc, ImportDLL und ASM importierten Funktionen:

    Beim Assemblieren wird aus FCALL dann "MOV EAX, Funktionsadresse" und "CALL EAX", wie auch im erzeugten Listing zu sehen ist. Das EAX-Register bietet sich hier an, weil es ja ehr von der Funktion verändert wird und das Ergebnis aufnimmt.
    Ach ja: Bei der innerhalb Windows gültigen Aufrufkonvention STDCALL ist immer die Funktion für das Aufräumen des Stacks zuständig. Das heißt, die auf den Stapel geschobenen Parameter werden von der Funktion wieder von diesem entfernt. Für den Stapel gilt "Last In - First Out", daher wird der erste Parameter zuletzt auf den Stapel gelegt.

    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

    Einmal editiert, zuletzt von RGH (25. März 2017 um 00:45)

  • Hallo Roland,
    sieht ja schon mal sehr gut aus.

    Eine Frage vorab hätte ich noch :

    Könntest du das auch in eine PROC...ENDPROC verpacken ?

    Code
    PROC XPos
    Parameters String such, text
      ' hier Parameterüberprüfung
       ASM "XPos", 2  
       ' evtl. gleich :  ASM "XPos", such, text
       .....
       .....
       ENDASM
    ENDPROC

    Wäre meiner Meinung nach übersichtlicher bzw. konformer.
    Es hätte auch einige Vorteile :
    - man könnte vorab schon die Parameter und deren Anzahl prüfen
    - Parameter-Typ prüfen evtl. abbrechen, Fehlermeldung usw.
    - bei optionalen Parametern evtl. vorbelegen
    - Fehlermeldung / Abbruch bei falschen Parametern
    - in Assembler ist sowas wohl eher schwieriger

    Das war das, was mir jetzt spontan einfiel.
    Man sieht es ja jetzt schon :
    Gib mal bei XPos eine Zahl statt eines Strings ein, egal ob 1. oder 2. Parameter.
    Da gibt es eine Schutzverletzung (Gott sei dank nicht mehr).

    Oder könnte man das in einer SET - Funktion ein/abschaltbar machen.
    Ich denke, wenn die ASM-Proc in einer Schleife aufgerufen wird, wird
    es wohl zu langsam. Anders, wenn eine ASM-Proc selber eine Schleife
    hat und nur einmal aufgerufen wird, macht es schon Sinn.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

    Einmal editiert, zuletzt von H.Brill (25. März 2017 um 09:47)

  • Den Bereich zwischen ASM und ENDASM (technisch gesehen handelt es sich um einen Befehl über mehrere Zeilen) in eine Prozedur zu packen, ist eine schlechte Idee, denn schließlich sollte der ASM-Befehl nur einmal aufgerufen werden, um die Funktion zu assemblieren und zur Verfügung zu stellen. Anschließend kann sie beliebig oft an beliebiger Stelle im Programm aufgerufen werden, genau so, wie etwa eine durch ImportFunc oder ImportDLL hinzugefügte Funktion. Es macht ja keinen Sinn diese mehrmals zu assemblieren.

    Allerdings steht es Dir frei, den Aufruf der neuen Funktion in eine Prozedur zu packen, um die Parameter zu überprüfen.

    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Ich sehe gerade :
    das geht :

    Code
    Proc XPos
    Parameters String s, t
      ' Parameter prüfen
      xpos(s, t)
    EndProc

    Ich dachte anfangs, daß die Proc und die Asm-Proc kollidieren, weil sie den
    gleichen Namen haben.
    Mehr wollte ich eigentlich auch nicht.

    PS:
    Wie werden die Parameter eig. referenziert ?
    Bin da nicht so der Fachmann.

    Ich lese öfter :
    MOV ESI,OFFSET VARIABLE

    Reicht da z.B. ein : MOV ESI,PARAM1
    Oder kann man das anders machen ?

    Auch ein Elementzeiger z.B. für ein Array
    add eax,[esi+4*ecx] funktioniert noch nicht.

    Müßte man dann alles in Einzelschritten, indem man
    Werte in Register schiebt, bzw. multipliziert, machen.

    Vielleicht weiß jemnad ein paar Tipps.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

    Einmal editiert, zuletzt von H.Brill (25. März 2017 um 14:25)

  • Da es noch keine Doku gibt, ist es an der Zeit, zu erwähnen, welche Assembler-Befehle unterstützt werden:

    Befehle mit zwei Parametern:
    MOV ADD SUB TEST CMP XOR OR AND XCHG
    Erlaubte Parameter: REG,REG - REG,[REG] - REG,[REG+-n] - REG,[REG+REG] - REG,nn - REG,[nn] - [REG],REG - [REG+-n],REG - [nn],REG

    Befehle mit einem Parameter:
    INC DEC MUL IMUL DIV IDIV NOT NEG CALL JMP
    In der Regel erlaubte Parameter:REG - [REG] - [nn] - [REG+REG] - [REG+-n]
    Bei CALL und JMP zusätzlich: Label

    Bedingte Sprünge:
    JZ, JNZ, JE, JNE, JO, JNO, JA, JNA, JS, JNS, JL, JLE, JG, JGE, LOOP
    Hier ist als Parameter nur ein Label erlaubt. (Zur Zeit nur Short-Sprünge, d. h. maximale Sprungweite +-127.) Bei LOOP wird das ECX-Register um 1 heruntergezählt und der Sprung erfolgt, wenn es auf 0 kommt.

    Shift-Operationen
    RCL RCR ROR ROL SAL SAR SHL SHR
    Erlaubte Parameter: REG - REG,n (Wird n nicht angegeben, wird um 1 Bit verschoben)

    Sonstige:
    PUSH POP NOP RET
    Bei PUSH und POP muss ein Register als Parameter angegeben werden. Bei RET kann ein Integer als Parameter angegeben werden.

    REG steht für ein Register, n für einen Byte-Wert, nn für einen Long-Wert. Die eckigen Klammern für eine Speicher-Adresse. Bei MOV REG, REG wird also der Inhalt des zweiten Registers ins erste kopiert, bei MOV REG,[REG] hingegen der Inhalt an der Adresse, die das zweite Register angibt.

    Das sollte fürs Erste reichen! ;)

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

    Einmal editiert, zuletzt von RGH (25. März 2017 um 14:46)

  • H.Brill: ASM-Funktion und Prozedur dürfen NICHT den gleichen Namen haben! Ansonsten geht es so!

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Eben gerade eine neue Version hochgeladen:

    Bei [REG+REG] wird jetzt auch die Skalierung unterstützt: [REG+REG*n].
    n darf die Werte 1, 2, 4 oder 8 haben. Die Schreibweise [REG+n*REG] ist nicht erlaubt.

    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Und hier etwas für die Mathematiker unter uns:


    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Ich denke auch, bis wir fertig sind, bzw. Roland fertig ist,
    wird's etwas mehr als ein rudimentärer Assembler.

    Und umso besser kann man auch dann damit arbeiten.

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • Oh, ich denke, mehr als rudimentär ist er jetzt schon! ;)

    Ach ja LOOPZ und LOOPNZ funktionierten auch schon!

    Neu dazugekommen in der eben hochgeladenen Version:

    CDQ ohne Parameter und LEA mit zwei Parametern, wobei der erste ein Register sein muss und der zweite keins sein darf.

    Bei PUSH und POP ist jetzt neben REG als Parameter auch [REG] erlaubt und bei PUSH darf als Parameter nun auch ein Integer angegeben werden, um gezielt einen Wert direkt auf den Stapel zu schieben.

    Außerdem ist bei den meisten Befehlen mit einem Parameter zusätzlich [Label] als Paramter erlaubt, während bei den meisten Befehlen mit zwei Parametern der erste nun auch [Label] sein kann oder der zweite [Label] oder Label.

    Zusätzlich gibt es folgende "Pseudo-Opcodes":

    DB n : fügt ein Byte ein
    DW nn : fügt ein Word (zwei Byte) ein
    DD nnnn : fügt ein Double-Word (vier Byte) ein
    DS "Text\z" : fügt einen String ein. Escape-Zeichen werden unterstützt. (Eingebettete Variablen natürlich nicht.)

    Ein kleines Beispiel:


    Gruß Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Als etwas größeres Beispiel mit Strings: die abgwandelte MsgBox:


    Man beachte:
    Bei Typ steht der Wert an der durch das Label "Typ:" angegebenen Adresse. Die Funktion erwartet den direkten Wert, deshalb wird hier der Wert, der an dieser Adresse steht nach EAX geholt: Das Label steht in eckigen Klammern.
    Bei den Texten, steht der Text jeweils an der durch das Label angegebenen Adresse. Da die Funktion hier die Adressen der Strings erwartet, werden diese direkt nach EAX kopiert, also steht das Label hier ohne eckige Klammern.

    Ach ja: Die Strings sollten natürlich mit einem Null-Byte ("\z") aufhören, sonst wird es seltsam. Und für den Typ wird ein DD-Speicherplatz (4 Byte = 32 Bit) benötigt, da MOVE EAX, [Label] einen 32-Bit-Wert von der angegebenen Adresse holt. (Bei z.B. MOV AL,[Label] hätte auch DB für ein Byte genügt.)

    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

    Einmal editiert, zuletzt von RGH (27. März 2017 um 21:03)

  • Und das an sich unsinnige Beispiel zeigt, dass man die Werte an den mit Dx reservierten Speicherstellen auch verändern kann:

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Ich denke, das reicht erst mal für den Inline-Assembler.

    Die anderen Erweiterungen funktionieren im Interpreter auch schon:

    MAT Var[] < n : Initialisierung der Elemente mit Index*n.
    ZIP Zipfile$ : Erstellt ein ZIP-Archiv Zipfile$ aus den Deteien in der Listboxliste, ggf. mit Ordern.
    UNZIP Zipfile$, Zielordner$: Entpackt das ZIP-Archiv Zipfile$ in den Ordner Zielordner$, ggf. mit Unterordnern.
    db("slxxx", ....): Unterstützung von SQLite-Datenbanken. Es muss lediglich die aktuelle SQLITE.DLL im Pfad sein. Keine Installation nötig. Befehlsumfang ähnlich wie bei db("fbxxx", ...).

    Wenn als Ergebnisdatei für Select-Statements (Set("SQLFile", ...)) eine Datei mit der Endung ".xml" angegeben ist, wird das Ergebnis als XML-Datei erzeugt.

    Das wäre es für's Erste.

    Wenn ich den Inline-Assembler nun dem Compiler und der Runtime beigebracht habe, steht dem Start der Subscription für X4 nichts mehr im Wege.

    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Toll finde ich, dass Assemblerfehler so gut abgefangen werden. Sehr lehrreich!

    Bitte könnte man noch um mov [reg1+reg2*n],reg ergänzen?
    mov reg,[reg1+reg2*n] klappt ja schon!

    Gruss

    HP255G7:Win10pro2.004,4*AMD Ryzen3200U@2.60GHz,6+2GB-RadeonVega/237GBSSD:intlDVDRW,3xUSB3 ext4TB-HDX,XProfanX3+Xasm/Xpse

    2 Mal editiert, zuletzt von p. specht (28. März 2017 um 20:23)

  • super Roland.
    man braucht ja auch noch so einiges.
    Was ich etwas bedauerlich finde ist,,
    man findet sehr wenig für 32 Bit Asm. Auch Bücher
    gibt es kaum. Alles nur 16 Bit und jede Menge
    für Mikrcontroller (AVR, STM32 usw.)

    Was ich nach langem Suchen gefunden habe :

    Das ist mal für mich interessant, weil man es immer wieder braucht.
    Muß ich mich mal am Wochenende hinsetzen.

    Doch wie programmiert man ein
    LODSB
    und ein
    MOV DL,BYTE [EBP+EBX]
    um, sodaß es auch für die neue Asmfunktion von XProfan paßt ?

    Die Makros da drin sind ja kein Problem (%1 = Param1 usw.).

    Wir sind die XProfaner.

    Sie werden von uns assimiliert.

    Widerstand ist zwecklos!

    Wir werden alle ihre Funktionen und Algorithmen

    den unseren hinzufügen.

  • Toll finde ich, dass Assemblerfehler so gut abgefangen werden. Sehr lehrreich!

    Bitte könnte man noch um mov [reg1+reg2*n],reg ergänzen?
    mov reg,[reg1+reg2*n] klappt ja schon!

    Gruss

    Ja kann man! Ist in der nächsten Version dabei. Das gilt dann natürlich für alle Befehle mit zwei Parametern.

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

  • Doch wie programmiert man ein

    LODSB
    und ein
    MOV DL,BYTE [EBP+EBX]
    um, sodaß es auch für die neue Asmfunktion von XProfan paßt ?

    LODSB entspricht MOV AL,[ESI] gefolgt von einem INC ESI bzw. DEC ESI, je nachdem wie das Richtungsflag gesetzt ist.
    Und bei MOV AL, ... kann man das "BYTE" weglassen, da ja aufgrund des Ziels klar ist, dass es hier nur um ein Byte geht.

    In der nächsten Version werden dann auch LODSB und LODSD funktionieren. LODSD entsprich einem MOV EAX,[ESI] gefolgt von einem Erhöhen oder Erniedrigen des Index-Registers ESI um 4.

    Gruß
    Roland

    Fujitsu Esprimo G5011 - Intel Core i5-10500T / 16 GB RAM / 500 + 2000 GB SSD / Windows 11pro - XProfan X4a

    Als Backup: Molegar Notebook - Intel Celeron N5095 / 16 GB RAM / 1000 GB HDD / Windows 11pro - XProfan X4a

    http://www.xprofan.de

Jetzt mitmachen!

Sie haben noch kein Benutzerkonto auf unserer Seite? Registrieren Sie sich kostenlos und nehmen Sie an unserer Community teil!