Hallo mal wieder,

bevor ich nun großartig damit anfange, etwas zu implementieren frage ich nach ergebnisloser Forensuche:
Hat sich schon jemand mit der x86-Codeerzeugung zur Laufzeit beschäftigt oder schon einmal etwas dazu gefunden? Klar gibt es dazu ein paar Artikel im Internet, aber noch hoffe ich auf den "hey, das hab ich doch auch schon gemacht"-Effekt hier im Forum

Letztlich geht es darum, Transformationsfunktionen für Bilddaten in einem Texteditor angeben zu können, die geparsed und übersetzt direkt als Code ausgeführt werden können.

Anbei mein erster "proof of concept"-Ansatz mit VirtualAlloc zum Holen einer page mit PAGE_EXECUTE_READWRITE-Rechten, was einigermaßen legitim sein sollte und auch mit No-Execute und den ganzen Schutzmechanismen klarkommen sollte. Ich habe gerade erst angefangen und eigentlich wollte ich einen externen compiler einbinden, der mir eine dll erzeugt, die ich dann nachladen kann. Diese Lösung ist mir aber nicht "kompakt" genug.

Ich bin gespannt, was ihr dazu sagen könnt, danke schonmal
Schlüsselworte hierzu wären : LocalAlloc, LocalProtect, PAGE_EXECUTE, ...

Einige der Mathe-Parser und Scripting-Engines hier im Forum nutzen soetwas.

(ich glaub der Parser von Dax und ein/zwei der "aktuellen" Script-Engines erstellen entsprechende Codes)

Danke für den Hinweis, Suchen ist immer eine Frage der treffenden Termini und unter "script engine" findet man schon einiges, etwa
http://www.delphipraxis.net/internal...t.php?t=159810
http://www.delphipraxis.net/internal...t.php?t=165328
http://www.delphipraxis.net/internal...ct.php?t=54895 (der von Dax)

Die Schwierigkeit wird nun sein, etwas recht kompaktes zu finden, das schnellen Code erzeugt. Je länger ich darüber nachdenke, destomehr wächst mein Interesse an der Thematik - sprich: wenn es die Zeit zulässt, wage ich mich selbst mal dran, einen Matheparser zu basteln. Wird das ein Spaß :>

mann könnte auch noch viele der Stringoperationen weglassen und durch knuffige "Integer" ersetzen

und wenn man dann noch die Speicherverwaltung den Prozeduren (wobei sich da eine Klasse gut eigenen würde) überläßt, dann könnte es am Ende eventuell etwa so aussehn

zusammenfalten · markieren

Delphi-Quellcode:

type TRegister = (rNone, rEAX, rEBX, rECX, rEDX, rSDI, ...);
  TComand = (cPUSH, cPOP, cMOV, ...);

procedure write_asm(code: Pointer; reg: TRegister; mem: Pointer = nil); overload;
procedure write_asm(code: Pointer; mem: Pointer; reg: TRegister = rNone); overload;

codeptr := CreateAsm;
AddAsm(codeptr, cPUSH, rEAX);
AddAsm(codeptr, cMOV, rEAX, $AABBCCDD);
AddAsm(codeptr, cPOP, rEAX);
AsmExecute(codeptr, u, v);
AsmFree(codeptr);

bzw. so

markieren

Delphi-Quellcode:

code := TAsm.Create;
code.Add(cPUSH, rEAX);
code.Add(cMOV, rEAX, $AABBCCDD);
code.Add(cPOP, rEAX);
code.Execute(u, v);
Asm.Free;

Eine Möglichkeit wäre auch noch meine Script-Engine.

Sie ist schnell, einfach und nicht wirklich groß.

Aber wo das hier mit ASM auftaucht hab ich selbst mal ne Frage:

Kennt jemand eine gute Seite u.a., womit man leicht in Assembler einsteigen kann?

MFG

Bitte erstelle dazu einen neuen Thread. Das gehört nicht wirklich hier rein.

@himitsu: guter Vorschlag. Ich bin hin- und hergerissen. Einerseits ist es mit Konstanten viel einfacher, da einem dann auch case-Anweisungen offenstehen, wo gerade noch Zeichenketten verarbeitet werden. Da ich den Ausdruck jedoch nur einmalig übersetzen muss, lockt irgendwo auch die Vorstellung, ein menschenlesbares Zwischenprodukt in assemblercode auszugeben, an dem man noch manuell herumoptimieren kann (wobei das bei meinem Grafikprogramm schon gewaltig an der Zielgruppe vorbeigeht *hust*). Wenn ich es textbasiert mache, kann ich Formelinterpreter und Übersetzer mit einem Zwischenzustand in Klartext trennen.
Dein Vorschlag, ein Assemblerobjekt zu bauen, nehme ich mir sehr zu Herzen, da ich im fertigen Programm nicht mehr mit Zeigern herumjonglieren will und das ganze auch irgendwo bequem verwendbar sein soll.

@olee: ich habe das meiste über Recherche herausgefunden. Unersetzliches Hilfsmittel ist zunächst einmal eine codetable http://www.jegerlehner.ch/intel/IntelCodeTable.pdf . Auch sehr nützlich finde ich die Referenz für erweiterte Befehle unter http://www.intel80386.com/simd/mmx2-doc.html , mithilfe dieser Seite habe ich schon mmx-optimiertes Alphablending und sse-optimierte Matrixmultiplikation umgesetzt (alphablending ist x5 schneller als generischer delphicode, die matrixgeschichte immerhin noch architekturabhängig bis zu 30%). du kannst mit inline assembler anfangen und einfache Routinen basteln, von dedizierten Assemblern wie a86 und dergleichen würde ich mal vorerst absehen, das erschlägt einen zu Beginn zu sehr. Was tutorials angeht, bin ich aber sehr ratlos und gebe die Frage an die anderen weiter.

hier 'ne kleine Spielerei

das läßt sich bestimmt noch extremst ausbauen und erweitern.

cool wäre auch, wenn die hinzugefügten Codes/Befehle erstmal in einer Tabelle/Liste gespeichert werden, so das man sie noch editieren kann und erst im Execute daraus der eigentliche ASM-Code zusammengesetzt wird.

zusammenfalten · markieren

Delphi-Quellcode:

Procedure TForm1.Button1Click(Sender: TObject);
  Var Code: TASM;
    i, i2: Integer;

  Begin
    i := StrToInt(Edit1.Text);
    i2 := StrToInt(Edit2.Text);
    Edit3.Text := 'calc';

    Code := TASM.Create;
    Try
      Code.Write(cPUSH, rECX);
      Code.Write(cMOV, rECX, 100);
      Code.Write(cIMUL, rEDX);
      Code.Write(cADD, rEAX, rECX);
      Code.Write(cPOP, rECX);
      Code.Write(cRET);
      Code.SetConvention(ccRegister);
      Code.AddPram(i);
      Code.AddPram(i2);
      i := Code.Execute;
      // i := Code.Result;
    Finally
      Code.Free;
    End;
    Edit3.Text := IntToStr(i);
  End;

man wird es nicht glauben, aber dieser hochkomplizierte Code kann höchst wissenschaftliche Berechnungen durchführen
i := i * i2 + 100; nicht wundern, da ist auch aktuell fast nichts und vieles teils hardkodiert drinnen, welches man genau für das Beispiel braucht
(das PUSH und POP ist natürlich nicht unbedingt nötig, aber so ist der Code etwas länger )


[add]
diese

markieren

Delphi-Quellcode:

For i := 7 downto 0 do Write(cNOP);
Write(cMOV, rEAX, nil);
Write(cJMP, rEAX);

ist jetzt einfach nur 'nen billiger Schutzblock, falls z.B. jemand das RET am Ende vergißt.

Hi,

ich habe meine Leidenschaft derweil noch etwas am Nutzerinterace abgekühlt, genauer gesagt habe ich mir konzeptionelle Gedanken gemacht und dann ein paar Steuerelemente zusammengestümpert und mich mit der Aktualisierung meiner polygon rendering - Routinen schwarzgeärgert (um die Vorschau schneller zugestalten, werden nur Übergitterpunkte berechnet und dann ein Polygonnetz gezeichnet, das 16x16, 32x32 oder 64x64 Quellpixel umfasst, was für die meisten Probleme gut ausreicht). Und so schauts nun aus...