Adressierung 32Bit 64Bit Architektur

Übersicht Sonstiges Smalltalk

Neue Antwort erstellen

Trust

Betreff: Adressierung 32Bit 64Bit Architektur

BeitragDo, Sep 21, 2017 16:30
Antworten mit Zitat
Benutzer-Profile anzeigen
Hallo,

mal eine generelle Frage.

In der 32Bit Architektur fast eine Adresse einen Speicherbereich von 8 Bit also 1 Byte und einen maximalen Adressenraum von 2^32 Adressen á 8 Bit. Bei einer 64 Bit Architektur ebenfalls 8 Bit also 1 Byte und einen maximalen Adressenraum von 2^64 Adressen á 8 Bit richtig?
Das heißt wenn ich von Adresse zu Adresse "springen" möchte und alle Werte dieser Adressen auslesen möchte, muss ich bei beiden Architekturen 8 Bit weise springen um Adresse für Adresse auszulesen?
Es gibt 10 Gruppen von Menschen: diejenigen, die das Binärsystem verstehen, und die anderen.
  • Zuletzt bearbeitet von Trust am Do, Sep 21, 2017 19:21, insgesamt 3-mal bearbeitet
 

CO2

ehemals "SirMO"

BeitragDo, Sep 21, 2017 17:35
Antworten mit Zitat
Benutzer-Profile anzeigen
Grundsätzlich stimmt das.

Wenn Du C oder C++ nutzt, kannst Du Zeigerarithmetik nutzen. Das ermittelt die "Sprungweite" bei einer gegebenen Startadresse (beispielsweise der Anfangsadresse eines Arrays) automatisch. Du kannst alternativ auch mit einer sizeof()-Konstellation an die Daten rankommen.

Hier mal ein kleines Beispiel zu Zeigerarithmetik Code: [AUSKLAPPEN]
#include <iostream>

int main(int argc, char **argv)
{
   int arr[] = { 1, 2, 3, 4, 5, 0 };
   int *val = arr;

   do
   {
      std::cout << *val << std::endl;
      val++;
   } while (*val != 0);

   getchar();

   return 0;
}


oder mit sizeof Code: [AUSKLAPPEN]
#include <iostream>


int main(int argc, char **argv)
{
   int arr[] = { 1, 2, 3, 4, 5, 0 };
   int start = (int)&arr;
   int index = 0;
   int *val;

   do
   {
      val = (int *)(start + index * sizeof(int));
      std::cout << *val << std::endl;

      index++;
   } while (*val != 0);

   getchar();

   return 0;
}
mfG, CO²

Sprachen: BlitzMax, C, C++, C#, Java
Hardware: Windows 7 Ultimate 64-Bit, AMX FX-6350 (6x3,9 GHz), 32 GB RAM, Nvidia GeForce GTX 750 Ti

Trust

BeitragDo, Sep 21, 2017 18:36
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich meinte das eigentlich "genereller".
Das ist eher Sprachenunabhängig gemeint.
Wenn ich zB. einen bestimmten Speicherbereich eines Prozesses auslesen möchte.
Sagen wir als ganz einfaches Beispiel einen Speicherbereich von 00112230 bis 00112240.
Dann nehmen wir an, wenn ich einen int32 auslesen möchte (4 Byte) das erste Byte am Anfang liegt, also bei 00112230 und das letzte Byte demnach bei 00112234. (Als Beispiel - könnte auch mitten drin liegen)
Also "adressiert" man mit einer Adresse nicht in 4 Byte schritten, sondern Byteweise. Quasi wie du sagtest nur den Anfang.

Nun ist meine Frage aber, wenn ich diesen Speicherbereich nach einem bestimmten Wert sagen wir 100 welcher als int32 vor der compilierung erstellt wurde(welche Sprache auch immer) durchsuchen möchte, welcher dann ja genau 4 Byte groß ist, wie stelle ich das an?
Ich meine woher weiß ich, welches Byte zu welchem Wert gehört?

Als Beispiel:
Adresse 00112230 + 4 Byte beinhaltet den Hexwert 00000064 (also Dezimal 100)
auf Adresse 00112235 befindet sich der Wert 0A (Dezimal 10)
Fange ich jetzt aber bei 00112231 + 4 Byte an zu lesen, erhalte ich nicht den gesuchten Wert 100 sondern in Hex 0000640A was den Dezimalwert 2660 ergäbe. Der Programmierer hatte aber nie einen Wert 2660 angelegt(als Beispiel), trotzdem würde man ja unter Umständen diesen Wert herauslesen können.
Demnach was völlig anderes.
Also wie würde man da vorgehen, wenn man den Wert 100 Typ 4 Byte in diesem Speicherbereich suchen wollen würde?

Hoffe das ist einigermaßen verständlich ausgedrückt. Confused
Es gibt 10 Gruppen von Menschen: diejenigen, die das Binärsystem verstehen, und die anderen.
 

ohaz

BeitragDo, Sep 21, 2017 19:40
Antworten mit Zitat
Benutzer-Profile anzeigen
bei deinem Vorgehen ist es nicht wirklich wichtig zu wissen, wie groß die pointer sind, sondern nur, wie groß die Datentypen sind, die du abspeichern möchtest.
Des weiteren ist wichtig, wie diese Datentypen gespeichert werden. Du musst wissen, ob deine CPU Little Endian oder Big Endian verwendet - das ist die Reihenfolge in der Bytes gespeichert werden. Man nehme an, du hättest einen 4 Byte Datentyp. In little Endian (der heutzutage typischen Endianess) wird das niederwertigste Byte zuerst gespeichert - d.h. 0xABCD wird in little Endian als 0xCD 0xAB abgespeichert. Daher kann es passieren, dass du deine Bytes falsch ausließt, wenn du sie als ints abspeichern lässt und nicht direkt als Byte.

Wenn es um den Rest geht: Wenn du einen 4 Byte großen Datentyp abspeicherst, kannst du sehr wohl 0xBADF00D + 4 rechnen um auf den nächsten, X byte großen Datentyp zu kommen.

FireballFlame

BeitragDo, Sep 21, 2017 19:51
Antworten mit Zitat
Benutzer-Profile anzeigen
Zitat:
Ich meine woher weiß ich, welches Byte zu welchem Wert gehört?

Gar nicht. In der Regel dürftest du Daten im Speicher zwar aligned vorfinden (d.h. ein int32 wird sich z.B. an einer Speicheradresse befinden, die durch 4 teilbar ist), dafür gibt es aber keine Garantie. x86-Prozessoren können prinzipiell mit beliebigen Speicheradresse umgehen (ggfs. mit Performanceeinbußen) und bestimmte Programmiersprachen wie C geben dem Programmierer z.T. Kontrolle darüber. Aber selbst wenn du das Bitmuster für die Zahl 100 irgendwo im Speicher findest, heißt das natürlich nicht, dass es sich auch tatsächlich um eine 100 handelt. Es könnte eine Gleitkommazahl sein, Teil einer größeren Ganzzahl oder sonstwas. Genaueres kriegst du höchstens mit sehr viel Beobachtungsaufwand bzw. mit dem dazugehörigen Programmcode raus.
PC: Intel Core i7 @ 4x2.93GHz | 6 GB RAM | Nvidia GeForce GT 440 | Desktop 2x1280x1024px | Windows 7 Professional 64bit
Laptop: Intel Core i7 @ 4x2.00GHz | 8 GB RAM | Nvidia GeForce GT 540M | Desktop 1366x768px | Windows 7 Home Premium 64bit
 

CO2

ehemals "SirMO"

BeitragDo, Sep 21, 2017 19:54
Antworten mit Zitat
Benutzer-Profile anzeigen
Hm, das gestaltet sich einigermaßen schwierig... Zum einen spielt da die Von-Neumann-Architektur eine Rolle, welche besagt, dass Programmcode und Daten zusammen in einem Speicher liegen. Das heißt, wenn ein simples Programm einen Speicher im RAM von 5 Byte belegt (ein Befehl mit einem Byte, zwei Adressen auf Ganzzahlen, je ein Byte und zwei Integer ebenfalls je ein Byte), muss zunächst der Befehl von den Arbeitsdaten unterschieden werden. Nehmen wir als Beispiel folgendes Programm Code: [AUSKLAPPEN]
Speicher  | Wert      | Wert
Adresse   | binär     | dezimal
-------------------------------
0000 0001 | 0110 0110 |     102
0000 0010 | 0000 0100 |       4
0000 0011 | 0000 0101 |       5
0000 0100 | 1000 0000 |     128
0000 0101 | 0100 0000 |      64
0000 0110 | 0000 0000 |       0
0000 0111 | 0000 0000 |       0
...

Da wir die Prozessorbefehle kennen, würden wir wissen, dass dezimal 102 dem Befehl "add" entspricht. In den zwei folgenden Speicherzellen stehen die Operatoren als Adresse (wird ebenfalls vom Prozessorhersteller festgelegt). Das heißt, den ersten Wert würden wir in Speicherzelle dezimal 4 finden, den zweiten Wert in Speicherstelle dezimal 5. Wenn wir diese beiden Werte haben, können wir die Werte der Speicherzellen an diesen Adressen auslesen und würden prüfen, ob sie den gesuchten Wert enthalten. Ist dies nicht der Fall, so würden wir eine Adresse weiter springen und den dortigen Befehl auslesen (In diesem Fall würde kein weiterer Befehl folgen, da die gespeicherten Werte den Platz für den nächsten Befehl belegen. Ein weiterer Befehl müsste im folgenden Beispiel an eigentlich an Adresse 4 stehen). Das heißt, wenn Du die Startadresse eines Prozesses hast, hast Du im Grunde genommen nur den Einstiegspunkt des Programms. Anhand der Prozessorbefehle müsstest Du dich von diesem Punkt an bis zu dem gesuchten Wert durchhangeln (nach o.g. Prinzip).
Dir werden jedoch einige Steine in den Weg gelegt.
Der erste: Du musst die Befehle des Prozessors und deren Parameter kennen.
Der zweite: Windows lädt große Programme nicht gesamt in den Speicher, sondern unterteilt diese in sogenannte Pages. So wäre beispielsweise die Rechtschreibprüfung in Word in einer Page, etc. Greifst Du auf eine nicht verfügbare Page zu, gibt es ein Page_Fault-Error.
Der dritte: Eigentlich lässt kein Betriebssystem zu, dass die Prozesse untereinander in den Speicherbereichen des jeweils anderen "rumpfuschen". Ein lesen kann, ein schreiben wird Dein Programm zum Absturz bringen.

Es sei noch gesagt, dass ich mich nie mit diesem Thema auseinandergesetzt habe, das oben genannte sind nur Mutmaßungen meinerseits, die ich im Zuge des Umgangs mit Mikroprozessoren gelernt habe.
mfG, CO²

Sprachen: BlitzMax, C, C++, C#, Java
Hardware: Windows 7 Ultimate 64-Bit, AMX FX-6350 (6x3,9 GHz), 32 GB RAM, Nvidia GeForce GTX 750 Ti

Trust

BeitragDo, Sep 21, 2017 21:13
Antworten mit Zitat
Benutzer-Profile anzeigen
Danke für die ausführlichen Antworten!

Ich schreibe zum besseren Verständnis einen Memory-reader/writer, weil ich wissen möchte wie andere Programme wie Oldbg, IDA, CheatEngine, ArtMoney und co. funktionieren. Wie diese eben Speicher auf bestimmte Werte auslesen, oder gar Programme disassamblieren, und debuggen.

Ich dachte, ich könnte meinen Memory-reader um eine Scanfunktion erweitern, welche den Speicher auf bestimmte Werte durchsucht.

Aber so wie ich das nun richtig verstanden habe, müsste ich dazu das zu scanende Programm erstmal komplett aus dem Speicher richtig als Maschinencode wieder zusammenpflücken und dann Zeile für Zeile den Maschinencode interpretieren.
Habe zwar Grundwissen in Assembler, aber das ist mir dann doch zu Aufwändig.

Hut ab vor den Entwicklern o.g. Programme.

Danke, habe nun einiges verstanden!
Es gibt 10 Gruppen von Menschen: diejenigen, die das Binärsystem verstehen, und die anderen.
 

ohaz

BeitragFr, Sep 22, 2017 14:53
Antworten mit Zitat
Benutzer-Profile anzeigen
Dazu kann ich dir tatsächlich noch ein bisschen was erzählen, da ich mich in meinem Studium wegen Compilerbau und Reverse Engineering doch etwas mit den Konzepten hinter OllyDBG, IDA usw auseinander gesetzt habe.

Erstmal zum disassemblieren:

Grundsätzlich ist das ein nicht gut lösbares Problem. Wie schon erwähnt, geht das ganze dank der von-Neumann Architektur etwas kaputt. Grundsätzlich gehen Programme wie IDA aber wie folgt vor:

* Auslesen, um welches Programmformat es sich handelt - heutzutage oft ELF
* Nachprüfen, an welcher Stelle im genannten Programmformat die Startadresse liegt. Diese muss irgendwo abgelegt sein (oder an einer festen Position sein), damit der Prozessor weiß, wo er mit der Ausführung beginnen soll.
* Versuchen von dieser Stelle an Code zu parsen, bis man an Funktionsaufrufe oder Funktionsenden kommt.
* Rekursiv für die Funktionsaufrufe weiter arbeiten.

Das Ganze funktioniert unter umständen ganz gut - allerdings gibt es immer noch des öfteren Probleme, weil z.b. ein Datenblock unterschiedlich lang sein kann und der Disassembler daher nicht zwingend weiß, wo der nächste Befehl losgeht. Daher probiert er einfach verschiedene Möglichkeiten aus und wählt die Wahrscheinlichste.


Das Auslesen von Arbeitsspeicher an sich ist da noch mal ein Stückchen schwerer. Ein vergleichsweise einfacher Punkt ist es, den Stack einer Funktion auszulesen - zumindest dynamisch. Man kann abfangen, an welchen Stellen der Stackpointer verschoben wird um somit auszulesen von wo bis wo der Stack der derzeitigen Funktion gerade geht.

Komplizierter wird es dann bei Pointern auf irgendwelche Stellen - da weiß auch ein Debugger nur über Heuristiken, ob es sich hierbei um Code oder Daten handelt. Meistens muss man bei solchen Sachen als Mensch mit seinem übergreifenden Wissen oder einfach gutem Bauchgefühl ran.


Wenn man selbst so Dinge wie ArtMoney oder CheatEngine programmieren will, gibt es da noch ein paar andere, einfachere Ansätze. Grundsätzlich werden in Spielen bestimmte Daten (wie z.b. HP) durch den deterministischen Aufbau oft an feste Stellen geschrieben (z.B. weil sie globale Variablen sind), oder haben zumindest eine generelle Struktur um sich herum. Daher lässt sich das Problem oft lösen, indem man einfach einen bestimmten Wert im Spiel erzeugt (z.b. 100 HP), danach den RAM des Spieles nach dem Wert 100 durchsucht, sich alle Stellen notiert an denen eine 100 auftaucht, den Wert im Spiel ändert (z.B. Schaden nimmt um auf 72 HP zu sein), die notierten Stellen nach einer 72 durchsuchen und alle Punkte wegschmeißen die keine 72 enthalten usw, bis man nur noch eine Position hat. Diese ist dann die Stelle im RAM, an der der gewünschte Wert abgelegt ist.


Ich hoffe ich konnte dir einen kleinen Einblick geben, falls du weitere Fragen hast, stell sie gerne.

Trust

BeitragFr, Sep 22, 2017 22:52
Antworten mit Zitat
Benutzer-Profile anzeigen
Ah das war sehr ausführlich.
Also wenn das so ist, dann ist es wohl doch nicht so schwierig meinen Memoryreader um so eine Scanfunktion ähnlich wie bei Cheatengine und ArtMoney zu erweitern.

Ich finde das Thema reverse engineering mega spannend. Wo kann man das lernen und in welchen beruflichen Bereichen ist das gefragt?
Ich fange am September 2018 nach meiner Elternzeit eine zweite Ausbildung zum Fachinformatiker Anwendungsentwicklung an. Wie könnte ich mich danach am besten beruflich in diese Richtung bewegen um in die Richtung reverse engineering, Assembler und low level programmierung zu kommen?
Es gibt 10 Gruppen von Menschen: diejenigen, die das Binärsystem verstehen, und die anderen.
 

ohaz

BeitragSa, Sep 23, 2017 7:52
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich habe Reverse Engineering an der Uni gelernt. Grundsätzlich würde ich mir erst mal wirklich relativ intensiv Assembler anschauen, so weit, dass du ein paar kleinere Funktionen lesen und vielleicht auch selbst schreiben kannst. Achte darauf, ob du Intel oder AT&T Syntax lernst, ich würde mir erst mal nur eines von beiden raussuchen und erstmal nur die lernen. Empfehlen kann ich die Intel Syntax.

Dazu eignet es sich, einfach ein kleines Programm in C zu schreiben und dann die Kombination aus gcc und objdump zu verwenden:
Code: [AUSKLAPPEN]
gcc -g -c test.c
objdump -d -M intel -S test.o


Da siehst du dann den Assembly Code deiner C Datei und kannst mal bisschen rumstöbern.


Danach wird es etwas verwaschener. Ich würde erstmal einfach die kostenlose Version von IDA Pro laden und damit einige ältere, kleinere Programme anschauen. Oder mir selbst "Passwort" Programme schreiben und diese in IDA Pro angucken. Es gibt dazu ein paar ganz akzeptable Bücher zum Reverse Engineering, aber der großteil ist wirklich das Ausprobieren.


Wo man da beruflich hin will ist eine sehr gute Frage. Mir hat das RE einfach insgesamt einen viel besseren Überblick über Programme im Allgemeinen gegeben und hilft auch bei meinem derzeitigem Tätigkeitsbereich als IT-Security Typ im IoT Bereich von Zeit zu Zeit. Wenn man RE wirklich hauptberuflich machen will muss man wohl zu spezialisierten Penetration Testing Firmen. Das höchste aller Gefühle ist da sicherlich bei Googles Project Zero zu landen, aber es gibt auch die ein oder andere Penetration Testing Firma. Da aber immer nachfragen ob man auch tatsächlich Reverse Engineering betreibt, es gibt manche Firmen, die verwenden nur bestehende Exploits und programmieren seltenst selbst was, andere bauen sehr spezifizierte Angriffe, da bringt das schon eher was.

Trust

BeitragSa, Sep 23, 2017 9:43
Antworten mit Zitat
Benutzer-Profile anzeigen
Ja, ich habe mir schon einige kleine Programme geschrieben, die einfach nur eine Variable definieren und ausgeben, oder eine Benutzereingabe ausgeben und solche Sachen, diese dann mit Olly disassambliert und verändert. Es gibt auch crackMe's von einfach bis extrem schwer die man versuchen kann zu knacken. Lernt man auch viel.
Mit IDA Pro habe ich bis jetzt noch nie gearbeitet, hatte es mir mal angeschaut. Kannst du das eher empfehlen als Olly?
Ich habe aber so das Gefühl ich komme nicht weiter, irgendwann wird das disassamblierte Programm so kompliziert und da merke ich, mangelt es mir am Know How. Und das ist dann so ein Teufelskreis, ich lerne nichts weil ich es nicht verstehe. Um es zu verstehen sollte ich es aber lernen...
Klar kann man sich ASM selber beibringen, wie C oder jede andere Sprache auch, allerdings ist es bei ASM mehr als nur einfach die Syntax und libs zu kennen. Und da wäre es gut jemanden zu haben der einem das Eine oder Andere mal erklärt. Ich habe bisher auch nur mit Flat Assembler herumgespielt. Ist das empfehlenswert für den Anfang oder eher was anderes?
Es gibt 10 Gruppen von Menschen: diejenigen, die das Binärsystem verstehen, und die anderen.
 

ohaz

BeitragSa, Sep 23, 2017 17:01
Antworten mit Zitat
Benutzer-Profile anzeigen
OllyDbg und IDA Pro verfolgen absolut unterschiedliche Ansätze - daher sind beide gut, je nach Verwendungszweck.

OllyDbg gehört zur "dynamischen" Analyse, wohingegen IDA Pro zur "statischen" Analyse gehört. Dynamisch bedeutet Analyse während dem Ausführen des Codes, statisch bedeutet Analyse ohne den Code auszuführen.

Wenn man Malware analysiert (was im Übrigen ein weiterer Jobbereich ist, Avira hat in Deutschland z.B. Stellen als Virenanalyst), hat man oft das Problem, dass man die Malware nicht selbst ausführen will. Selbst wenn man sie in VMs ausführt, gibt es durchaus Möglichkeiten aus der VM auszubrechen und doch wieder alles zu infizieren. Ausserdem erkennt Malware oft, dass sie in einer VM läuft (z.B. an der Geschwindigkeit in der Sekunden ablaufen) und macht dann nichts "böses". Da bringt dir dynamische Analyse dann nichts, da muss statische Analyse her.

Im Gegenzug ist es oft einfacher Code dynamisch zu analysieren, als ihn statisch zu analysieren. Gute Malware ist oft gepackt, richtig gute Malware verschlüsselt sich sogar selbst - und richtig super gute Malware verschlüsselt eigene Teile unterschiedlich, mit unterschiedlichen Schlüsseln, so dass es quasi unmöglich wird das ganze statisch zu analysieren. Da ist eine dynamische Analyse gut, weil der Code ja zu irgend einem Zeitpunkt tatsächlich ausgeführt werden muss - und zu dem Zeitpunkt ist er unverschlüsselt. Ausserdem ist dynamische Analyse oft einfacher als statische Analyse, weil man sehen kann wie der Kontrollfluss tatsächlich abgelaufen wird, welche Teile des Codes oft ausgeführt werden, was dabei in den Variablen steht etc., was bei statischer Analyse schwer ist.

Trust

BeitragSa, Sep 23, 2017 17:41
Antworten mit Zitat
Benutzer-Profile anzeigen
Du kennst dich aber gut aus.
Ja, Avira hat ihren Hauptsitz ja in Tettnang bei Friedrichshafen (20 mit dem Auto von mir), die suchen Azubis, deshalb wollte ich da meine Ausbildung machen, da ich denke dass das in die Richtung geht wo ich anstrebe. Wenn sequrity dann so eine Firma. Vielleicht habe ich dort die Möglichkeit in alle Teilbereiche mal reinzuschauen.
Würde ein kleiner Traum in Erfüllung gehen, wenn ich dort eine Ausbildung machen könnte. Oder ein vergleichbares Unternehmen.
Es gibt 10 Gruppen von Menschen: diejenigen, die das Binärsystem verstehen, und die anderen.

Thunder

BeitragSa, Sep 23, 2017 23:41
Antworten mit Zitat
Benutzer-Profile anzeigen
Ein paar kleine Anmerkungen hier und da:

Zitat:
Also "adressiert" man mit einer Adresse nicht in 4 Byte schritten, sondern Byteweise.


Für PCs stimmt das. Es gibt aber Architekturen, die nicht byteweise sondern wortweise addressieren (alle 2 oder 4 Byte z.B.). Da müsstest du dir dann ein Byte/Bytefolge zusammenpflücken, wenn sie nicht an die Wortgröße aligned ist.

Zitat:
Nun ist meine Frage aber, wenn ich diesen Speicherbereich nach einem bestimmten Wert sagen wir 100 welcher als int32 vor der compilierung erstellt wurde(welche Sprache auch immer) durchsuchen möchte, welcher dann ja genau 4 Byte groß ist, wie stelle ich das an?


Da brauchst du dann schon sehr betriebssystemspezifischen Code. Du möchtest ja den Speicher eines laufenden Prozesses untersuchen, dazu brauchst du den entsprechenden Systemcall (ptrace in Linux). Dann kannst du auf irgendeine Weise Zugriff nehmen auf die Speicherseiten, die der Prozess sehen kann (unter Windows führt der Prozess selber eine Linked List darüber und du kannst auf die Kerneltabelle auch zugreifen). Jetzt kannst du diese Speicherseiten durchsuchen, du wirst unter Umständen mehrere Stellen finden, an denen der Wert vorkommt. Falls du nach einem Daten-wert suchst (also diese 100 sind Programmdaten und nicht Programmcode), solltest du zusätzlich nur Speicherseiten mit Read-Write Berechtigung durchsuchen.

Zitat:
Aber so wie ich das nun richtig verstanden habe, müsste ich dazu das zu scanende Programm erstmal komplett aus dem Speicher richtig als Maschinencode wieder zusammenpflücken und dann Zeile für Zeile den Maschinencode interpretieren.


Wenn du nur nach (variablen) Werten scannen willst, reicht das oben genannte Vorgehen. Dann befindet sich der Wert nämlich sehr wahrscheinlich irgendwo im (Daten-)Speicher. Wenn der Wert eine Konstante ist, könnte er natürlich Teil eines Maschinenbefehls sein. Beispiel:
BlitzMax: [AUSKLAPPEN]
Function foo(x)
Return x+5
EndFunction


könnte so aussehen (x86, 32bit):
Code: [AUSKLAPPEN]
foo:
mov eax, [esp+4]
add eax,5
ret


Die 5 findest du dann nicht so wie oben beschrieben.

Zitat:
Ich habe bisher auch nur mit Flat Assembler herumgespielt


Flat Assembler ist super. Meiner Meinung nach hat er die einfachste Syntax, aber ist auch nicht weit von nasm (der weiter verbreitet ist). Zusätzlich verwendet BlitzMax fasm.
Meine Sachen: https://bitbucket.org/chtisgit https://github.com/chtisgit

Neue Antwort erstellen


Übersicht Sonstiges Smalltalk

Gehe zu:

Powered by phpBB © 2001 - 2006, phpBB Group