Intel X86-64 Montage-tutorials oder ein Buch

Zugegeben, es ist die persönliche Befangenheit, wie Sie lieber zu lernen über die Programmierung.

Aber mit Respekt zur Versammlung Sprachen im besonderen, fand ich einen Ansatz, der mir mehr als nützlich, reading instruction set reference manuals und/oder Bücher über Assembler (wo Sie existieren).

Was ich normalerweise tun, um herauszufinden, wie Montagearbeiten für eine neue CPU /ein CPU unbekannt, um mich auf eine OS-Plattform habe ich nicht gearbeitet und dennoch ist die Nutzung der developer-toolchain. So:

• installieren Sie sich selbst ein (cross-)compiler und disassembler für die Ziel-CPU. In diesen Tagen, GNU gcc /binutils ubiquity oft bedeuten, dass die gcc und objdump -d.

• erstellen Sie eine Reihe von kleinen Programmen /kleine Stücke von sourcecode, wie:

extern int funcA(int arg);
extern int funcB(int arg1, int arg2);
extern int funcC(int arg1, int arg2, int arg3);
extern int funcD(int arg1, int arg2, int arg3, int arg4);
extern int funcE(int arg1, int arg2, int arg3, int arg4);
extern int funcF(int arg1, int arg2, int arg3, int arg4, int arg5);
extern int funcG(int arg1, int arg2, int arg3, int arg4, int arg5, int arg6);
extern int funcH(int arg1, int arg2, int arg3, int arg4, int arg5, int arg6,
                 int arg7);

int main(int argc, char **argv)
{
    printf("sum of all funcs: %d\n",
        funcA(1) + funcB(2, 3) + funcC(4, 5, 6) + funcD(7, 8, 9, 10) +
        funcE(11, 12, 13, 14, 15) + funcF(16, 17, 18, 19, 20, 21) +
        funcG(22, 23, 24, 25, 26, 27, 28) + funcH(29, 30, 31, 32, 33, 34, 35));
    return 12345;
}

• kompilieren Sie diese mit compiler-Optimierung und zerlegen die generierte Objekt-code.
  
  Die Struktur des Codes ist einfach genug, um zu zeigen, wie die ABI verhält wrt. zu Funktion aufrufen, Argumente übergeben und zurückgeben von Werten, Verwaltung des Registers Raum wrt. um die Register sind erhaltene /volatile machen, wenn Funktionsaufrufe. Es wird auch zeigen Ihnen einige grundlegende Assembler-code für die Initialisierung Konstante Daten, und "Kleber" wie stack-Zugriff und-Verwaltung.

• erweitern diese für einfache C-Sprachkonstrukte wie Schleifen und if/else oder switch Aussagen. Halten Sie immer einige Anrufe zu externen Undefinierte Funktionen, weil dies verhindert, dass der compiler optimizer werfen Sie alle Ihre "test-code" aus, und wenn Sie if() tests von switch(), Prädikat auf argc (oder eine andere Funktion Argumente), weil der compiler nicht Vorhersagen kann, dass entweder (und damit zu optimieren, die Bausteine der code "unheimlich").

• erweitern diese für die Verwendung struct {} und class {} Definitionen mit Sequenzen von verschiedenen primitiven Datentypen, um heraus zu finden, wie der compiler ordnet diese im Speicher, die Montage-Anweisungen werden verwendet, um den Zugang bytes/Worte/ints/longs/Schwimmer usw.
  
  Alle diese Teile der test-code kann man gezielt variieren (wie andere Vorgänge als +), und/oder komplexer, um zu lernen, mehr über bestimmte Teile der Befehlssatz und die ABI.

Nachdem Sie dies getan haben, und schaute auf den Ausgang, suchen Sie eine Kopie (elektronisch oder nicht) der Plattform ABI. Enthält das Regelwerk, wie das oben geschehen ist /warum es gemacht wird, die Art und Weise, und es wird Ihnen helfen, bekommen ein Gefühl dafür, warum diese Regeln gelten für die spezifische Plattform. Es ist wichtig, um eine Vorstellung über die da oben, wenn Sie schreiben Ihre eigenen Assembler-code, müssen Sie die Schnittstelle, die mit anderen non-Montage (es sei denn, für rein-demos). Das ist, wo Sie brauchen, nach den Regeln zu spielen, also auch wenn Sie weiß Sie nicht auswendig, zumindest wissen, wo die Anleitung ist.

Erst danach würde ich vorschlagen, Sie tatsächlich auf die Spur der Befehlssatz Referenz für die jeweilige Plattform.

Das ist, weil, wenn Sie gegangen sind, durch den oben genannten ersten, dann haben Sie schon genug Erfahrung mit /du hast schon genug gesehen, um zu starten mit einem kleinen C-Programm, kompilieren Sie es auf der Montage-Quelle ändern, dass ein wenig, montieren und verbinden Sie es und sehen, ob Ihre änderungen das tut, was es tun soll.

Versucht, auf die Bühne, etwas mehr ungewöhnlich /spezielle Anweisungen wird viel leichter sein, weil Sie gesehen haben, wie die Funktion aufrufen funktioniert, welche Art von glue-code ist notwendig, um die Schnittstelle Ihrer Montage mit anderen teilen des Programms, Sie habe bereits mit der toolchain, so dass Sie nicht brauchen, um zu starten, ganz von vorne mehr.

I. e., zusammenfassend diese alle, mein Vorschlag ist, zu lernen, Montage von die top-down - statt von unten nach oben.

Seite Hinweis:

Warum bin ich darauf hindeutet, verwenden compiler-Optimierung bei der Analyse der vom compiler generierten Assembler-code für solch einfache Beispiele ?

Nun, die Antwort ist da, counterintuitively, um einige der generierte Assembler-code ist viel einfacher, wenn man den compiler optimieren Sie die Hölle aus der Dinge. Ohne Optimierungen, die Compiler erzeugen oft "dumm" - code, z.B. setzt alle Variablen in den stack, speichert und stellt Sie von dort aus keinen Grund, dass Sie sehen können, hat register speichert/wiederherstellt/Initialisierungen nur zu überschreiben, dass reg die nächste Anweisung und viele weitere solche Dinge. Die Menge an code, die emittiert wird, ist viel viel größer, weil dieser. Es ist gespickt mit cruft und viel schwerer zu verstehen. Die compiler-Optimierung Kräfte trimmen diese Reste nach unten auf das wesentliche, ist das, was Sie sehen wollen, um zu verstehen, die Plattform ABI, und die assemnbly. Daher verwenden compiler-Optimierung.