Erste Schritte mit der Montage

Montage ist eine Low-Level-Sprache, deren Funktion es ist, alle notwendigen Elemente für die Programmierung der Architektur von Desktop-PCs oder Laptops bereitzustellen. Seine Lernkurve ist etwas steil und nur sehr wenige Konzepte können aus Hochsprachen wie z Python, Ruby oder JavaEs ist jedoch die mächtigste Sprache für die Programmierung von Architekturen basierend auf x64.
Obwohl es sich um eine komplexe Sprache handelt, lässt sie in ihren aktuellen Versionen die Verwendung von Hexadezimalzahlen beiseite und ersetzt sie durch Namenskonventionen, die leichter zu merken und zu lesen sind, zusätzlich zu höheren Eigenschaften wie der Verwendung von Makros und benutzerdefinierten Einschlüssen Datentypen.
Wenn der Entwicklungsprozess beendet ist, werden diese Codezeilen vom Assemblerprogramm gelesen und dann durch einen ähnlichen Prozess wie der von . in Maschinencode übersetzt Zusammenstellung in Hochsprachen aber hier heißt es beitreten.
Für die Zwecke dieses Tutorials werden wir zunächst sehen, wie der Codierungsprozess in 32-Bit, da es ein grundlegender Schritt ist, um ein besseres Verständnis der Sprache und des Kodierungsprozesses in Anwendungen von 64-Bit, dies, indem viele Eigenschaften mit der Architektur geteilt werden x86 64-Bit.
Es gibt viele Möglichkeiten, mit dem Codieren zu beginnen Montage für 32-Bit-Anwendungen, aber eine der einfachsten und praktischsten Möglichkeiten ist, dies zu tun Visuelles Studio da es sowas heißt online montiert wo der Code von Montage ist eingebettet in C++ normal und aktuell, dies kann in einer einzigen Zeile oder in Codeblöcken mit dem reservierten Wort erfolgen __asm.
WichtigDas Schlüsselwort __asm ​​kann mit einem einzelnen Unterstrich verwendet werden. Dies ist eine alte Richtlinie, die verwendet wird, um die Kompatibilität in weniger modernen Anwendungen sicherzustellen.
Nachdem wir dies geklärt haben, müssen wir uns als erstes besorgen Visuelles Studio, für dieses Tutorial haben wir die Version verwendet äußern Der Code ist jedoch in beiden Versionen des gültig SDI. Wir laden im folgenden Link unsere SDI und wir führen im Installer aus:

Nachdem der Installationsprozess abgeschlossen ist, können wir mit der Codierung beginnen Montage, dafür machen wir ein kleines Beispiel, in dem wir zeigen, wie wir den Code von einbetten können Montage In C++ mit dem reservierten Wort __asm, wobei jedes Codesegment neben diesem Wort als nativer Code von . behandelt wird Montage vom Compiler C++.
Wir öffnen unser Visual Studio und erstellen ein neues Projekt vom Typ Win32-Konsolenanwendung, wir drücken In Ordnung und der Assistent zur Projekterstellung wird angezeigt, der uns fragt, welche Art von Projekt wir möchten. Wenn wir ein leeres Projekt wünschen, empfehlen wir, alle Standardoptionen zu belassen und zu drücken Abschließen:

VERGRÖSSERN

Der Assistent erstellt einen Basiscode für unser Projekt, der eine Bibliothek und die Hauptmethode enthält. Er sollte so aussehen:

 #include "stdafx.h" int _tmain (int argc, _TCHAR * argv []) {return 0;}

Nachdem wir jetzt den Basiscode haben, müssen wir unsere Zeile hinzufügen Montage, zusätzlich müssen wir die Bibliothek hinzufügen, um über die Konsole drucken zu können und die Namensraum Damit alles richtig funktioniert, sehen wir uns den endgültigen Code an:

 #include "stdafx.h" #include mit Namespace std;int _tmain (int argc, _TCHAR * argv []) {int x = 0; _asm mov x, 25 cout << "Der Wert für x ist:" <<>

Was wir hier gemacht haben, ist eine Variable namens x zu definieren und dann durch Code Montage wir weisen ihm den Wert 25 zu, um ihn schließlich mit auszudrucken cout, wie wir sehen können, ist das Einbetten der Montagecode, jetzt müssen wir nur noch unser kleines Programm ausführen, dafür können wir drücken Strg + F5 wo unser Programm kompiliert und ausgeführt wird, sehen wir uns an, wie diese Operation aussieht:

VERGRÖSSERN

Zusätzlich können wir mehrere Codezeilen von Montage in unserem Code C++, was wir erreichen können, indem wir das reservierte Wort platzieren __asm und einen Codeblock öffnen, sehen wir uns an, wie wir dies erreichen:

 float Sqrt (float f) {__asm ​​​​{fld f // f auf den Operations-Stack setzen fsqrt // sqrt berechnen}}

Vorteile der Inline-MontageEs gibt viele Vorteile der Verwendung von Inline-Assembly anstelle einer nativen Anwendung von 32-Bit von Montage, zum Beispiel das Senden von Parametern an die Funktionen wird vollständig vom Compiler von C++ und es wird die genaue Menge an Maschinencode injiziert, sodass wir uns keine Sorgen über einen Speicherüberlauf oder ähnliches machen müssen.
Aber so wie wir Vorteile haben, finden wir auch Nachteile in dieser Art der Codierung, einer davon ist, dass der Entwickler ein bisschen die Kontrolle über die Anwendung verliert, etwa den Stack zu manipulieren oder sogar eigene Konventionen zu definieren.
Online-Assembly bietet viel Flexibilität und ermöglicht es uns, schnell und einfach in diese Welt einzusteigen, aber diese Codierungsmethode verhindert, dass Entwickler auf einige Assembly-Elemente zugreifen können. Aus diesem Grund ist es üblich, unserem Projekt nativen und separaten Code hinzuzufügen.
Dazu müssen wir unsere Dateien separat erstellen und dann die erforderlichen Methoden einbinden, um unser Ziel zu erreichen, gehen wir wie folgt vor:
1- Zuerst erstellen wir ein neues Projekt, es kann ein Projekt vom Typ sein C++ oder von Windows-App, beide funktionieren, um die Dateien von . hinzuzufügen Montage.
2- Wir fügen eine Datei hinzu C++ zu unserem Projekt, das wir anrufen werden Principal.cpp die dafür zuständig ist, eine Prozedur aus unserer Datei aufzurufen Montage Senden Sie ihm ein Array mit numerischen Werten und drucken Sie dann aus, was dieses Verfahren zurückgibt. Sehen wir uns den Inhalt unserer Datei an Principal.cpp:

 #include using namespace std; extern "C" int findMinorNum (int * i, int count); int main () {int arr [] = {4, 2, 6, 4, 5, 1, 8, 9, 5, -5}; cout << "Die kleinste Zahl ist:" << findMinorNum (arr, 10) << endl; cin.get(); 0 zurückgeben;}

3- Dann klicken wir mit der rechten Maustaste auf unser Projekt, es befindet sich auf der rechten Seite unserer Benutzeroberfläche im Abschnitt von Lösungsforscher. Wir wählen die Abhängigkeiten aufbauen und später Anpassungen erstellen. Wir tun dies, um festzulegen, wie Visual Studio Dateien mit der Erweiterung behandelt .asmDa wir nicht möchten, dass der C++-Compiler diese Dateien kompiliert, ist es unser Ziel, dass VS diese Dateien zur Verfügung stellt MEHR M damit ich sie zusammenbaue und dann diese mit unserem C ++ verknüpften Dateien für die Bildung der endgültigen ausführbaren Datei verantwortlich sind.
4- Um mit den Abhängigkeiten abzuschließen, wählen wir die Option von mehr M wie wir im folgenden Bild sehen können:

VERGRÖSSERN

Es ist wichtig, diesen Schritt auszuführen, bevor Sie Dateien mit Assembly-Code als . hinzufügen Visuelles Studio weist zu, was eine Datei beim Erstellen und nicht beim Erstellen tun muss.
5- Dann müssen wir eine weitere C++-Datei hinzufügen, diesmal jedoch mit der Erweiterung .asm, für dieses Tutorial habe ich es genannt Assembler.asm. Auf die gleiche Weise können wir ihm einen beliebigen Namen mit Ausnahme von main.asm geben, da der Compiler Probleme haben kann, die Hauptmethode zu finden.
6- Unser Archiv Assembler.asm Es wird dafür verantwortlich sein, aus einer Reihe von Zahlenwerten zu berechnen, welcher der kleinste Wert unter diesen ist und dann C++ Es kümmert sich darum, den Wert zu erhalten, um ihn durch cout zu verarbeiten. Sehen wir uns den Inhalt unserer Datei an:

; Assembler.asm.xmm.model flat, c.data.code findNumMenor proc exportmov edx, dword ptr [esp + 4]; mov ecx, dword ptr [esp + 8]; mov eax, 7fffffffh; cmp ecx, 0; jle Fertig ;MainLoop: cmp dword ptr [edx], eax; cmovl eax, dword ptr [edx]; add edx, 4; dec ecx; jnz MainLoop; Fertig: ret; findNumMinor endpend

Dies ermöglicht uns, unsere Dateien sowie unsere Logik zu trennen. Die Realisierung dieser auf 32 Bit basierenden Prozeduren wird sehr wenig verwendet, aber es ist wichtig, alle ihre Auswirkungen zu kennen. Sehen wir uns nun an, wie wir unseren Code für eine Anwendung von ändern 64-Bit sowie die Schritte, die wir unternehmen müssen, um unsere Umgebung von Visuelles Studio.
Visual Studio enthält alle notwendigen Tools, um die native Assembly zu unserem Projekt hinzuzufügen C++, aber basierend darauf zu arbeiten 64-Bit Wir müssen einige zusätzliche Konfigurationen für unser Projekt vornehmen, mal sehen:
1- Die Schritte zur Durchführung dieser Art der Codierung ähneln unserem vorherigen Beispiel, müssen jedoch angepasst werden VS Wir gehen zur Option Bauen und wir wählen aus Konfigurationsmanager:

2- Im Konfigurationsmanager-Bildschirm werden wir die Option auswählen Neu oder neu in der Plattformspalte, die einen zweiten Bildschirm zur Auswahl der Projektplattform anzeigt, wählen wir aus x64 und in der Option Einstellungen kopieren von Wir haben die Option ausgewählt Win32. Das wird VS Versionspfade ändern von 32-Bit von MEHR M zu dem von 64, die gesamte Arbeit wird also von der IDE erledigt.

VERGRÖSSERN

3- Sobald dies erledigt ist, können wir unseren Code kompilieren und ausführen, müssen jedoch unsere Datei ändern Montage Da wir an verschiedenen Architekturen arbeiten, sehen wir uns den neuen Code für unsere Datei an:

; Auflistung: Assembler.asm .code; int findMinorNum (int * arr, int count) FindSmallest proc; mov eax, 7fffffffh; cmp edx, 0;jle Fertig; MainLoop: cmp dword ptr [rcx], eax; cmovl eax, dword ptr [rcx]; rcx hinzufügen, 4; dec edx; jnz MainLoop; Abgeschlossen: ret; FindSmallest endp; Ende;

Damit beenden wir dieses Tutorial, mit dem wir bereits einen ersten Blick auf die Programmierung geworfen haben Montage, es mag auf den ersten Blick etwas komplex erscheinen, aber mit einer angemessenen Beherrschung von C++ und Grundbegriffe der Maschinensprache können wir mit unseren Entwicklungen Interessantes und Nützliches erreichen.Hat dir dieses Tutorial gefallen und geholfen?Sie können den Autor belohnen, indem Sie diesen Knopf drücken, um ihm einen positiven Punkt zu geben