Eerste stappen met montage

bijeenkomst is een taal op laag niveau waarvan de functie is om alle noodzakelijke elementen te bieden voor het programmeren van de architectuur van desktop-pc's of laptops. De leercurve is een beetje steil en er kunnen maar heel weinig concepten worden toegepast vanuit talen op hoog niveau, zoals: Python, Ruby of JavaHet is echter de krachtigste taal voor het programmeren van architecturen op basis van: x64.
Ondanks dat het een complexe taal is, laat het in de meest recente versies het gebruik van hexadecimalen buiten beschouwing en vervangt het door naamgevingsconventies die gemakkelijker te onthouden en te lezen zijn, naast hogere kenmerken zoals het toestaan ​​van het gebruik van macro's en opname door de gebruiker gedefinieerd gegevens typen.
Wanneer het ontwikkelingsproces eindigt, worden deze coderegels gelezen door het assemblageprogramma en vervolgens vertaald in machinecode door een proces dat vergelijkbaar is met dat van compilatie in talen op hoog niveau, maar hier wordt het genoemd meedoen.
Voor de doeleinden van deze tutorial zullen we in eerste instantie zien hoe het coderingsproces is in 32 bits, aangezien het een fundamentele stap is om een ​​beter begrip te krijgen van de taal en het coderingsproces in toepassingen van 64 bits, dit door veel kenmerken te delen met de architectuur x86 64-bits.
Er zijn veel manieren om te beginnen met coderen bijeenkomst voor 32-bits toepassingen, maar een van de gemakkelijkste en meest praktische manieren om dit te doen, is door Visuele studio omdat het iets heeft genaamd online geassembleerd waar de code van bijeenkomst is ingebed in C ++ normaal en actueel, dit kan in een enkele regel of in codeblokken met het gereserveerde woord __asm.
BelangrijkHet __asm-zoekwoord kan worden gebruikt met een enkel onderstrepingsteken. Dit is een oude richtlijn die wordt gebruikt om compatibiliteit in minder moderne toepassingen te garanderen.
Nadat we dit hebben verduidelijkt, is het eerste wat we moeten doen het verkrijgen van Visuele studio, voor deze tutorial hebben we de versie gebruikt nadrukkelijk de code is echter geldig in beide versies van de SDI. We downloaden in de volgende link onze SDI en we draaien in het installatieprogramma:

Nadat het installatieproces is voltooid, kunnen we beginnen met coderen bijeenkomst, hiervoor zullen we een klein voorbeeld maken waarin we zullen laten zien hoe we de code van kunnen embedden bijeenkomst in C ++ met het gereserveerde woord __asm, waarbij elk codesegment naast dit woord wordt behandeld als native code van bijeenkomst door de compiler C++.
We openen onze Visual Studio en maken een nieuw project van het type Win32 Console-toepassing, we duwen Oke en de wizard voor het maken van projecten wordt weergegeven, die ons zal vragen welk type project we willen en als we een lege willen, raden we aan om alle standaardopties te verlaten en op te drukken Afronden:

VERGROTEN

De wizard maakt een basiscode voor ons project, die een bibliotheek en de hoofdmethode zal bevatten, het zou er als volgt uit moeten zien:

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

Nu we de basiscode hebben, moeten we onze regel van toevoegen bijeenkomst, bovendien moeten we de bibliotheek toevoegen om per console te kunnen printen en de naamruimte zodat alles correct werkt, laten we de laatste code bekijken:

 #include "stdafx.h" #include met namespace std;int _tmain (int argc, _TCHAR * argv []) {int x = 0; _asm mov x, 25 cout << "De waarde voor x is:" <<>

Wat we hier hebben gedaan, is een variabele met de naam x definiëren en vervolgens via code bijeenkomst we kennen het de waarde van 25 toe, om het uiteindelijk af te drukken met cout, zoals we kunnen zien, is het een vrij eenvoudig proces om de Montagecode:, nu hoeven we alleen maar ons kleine programma uit te voeren, hiervoor kunnen we op . drukken Ctrl + F5 waar ons programma zal worden gecompileerd en uitgevoerd, laten we eens kijken hoe deze bewerking eruit ziet:

VERGROTEN

Bovendien kunnen we meerdere regels code opnemen uit: bijeenkomst in onze code C ++, wat we kunnen bereiken door het gereserveerde woord te plaatsen __asm en het openen van een codeblok, laten we eens kijken hoe we dit bereiken:

 float Sqrt (float f) {__asm ​​​​{fld f // Zet f op de operations-stack fsqrt // Bereken sqrt}}

Voordelen van inline montageEr zijn veel voordelen aan het gebruik van inline assemblage in plaats van een native applicatie van: 32 bits van bijeenkomst, bijvoorbeeld het verzenden van parameters naar de functies wordt volledig afgehandeld door de compiler van C ++ en het zal de exacte hoeveelheid machinecode injecteren, zodat we ons geen zorgen hoeven te maken over een geheugenoverloop of iets dergelijks.
Maar net zoals we voordelen hebben, vinden we ook nadelen aan deze manier van coderen, een daarvan is dat de ontwikkelaar een beetje controle over de applicatie verliest, zoals het manipuleren van de stapel of zelfs het definiëren van zijn eigen conventies.
Online assemblage biedt veel flexibiliteit en stelt ons in staat om deze wereld snel en gemakkelijk te betreden, maar deze coderingsmethode voorkomt dat ontwikkelaars toegang hebben tot sommige assemblage-elementen, daarom is het gebruikelijk om native en aparte code aan ons project toe te voegen.
Hiervoor moeten we onze bestanden afzonderlijk maken en vervolgens de methoden opnemen die we nodig hebben, om ons doel te bereiken gaan we de volgende stappen volgen:
1- Eerst maken we een nieuw project, het kan een project van het type zijn C ++ of van windows-app, beide werken om de bestanden toe te voegen van bijeenkomst.
2- We voegen een bestand toe C ++ naar ons project dat we zullen bellen opdrachtgever.cpp die verantwoordelijk is voor het oproepen van een procedure uit ons bestand bijeenkomst het een reeks numerieke waarden verzenden en vervolgens afdrukken wat deze procedure retourneert, laten we de inhoud van ons bestand bekijken opdrachtgever.cpp:

 #include met 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 << "Het kleinste getal is:" << findMinorNum (arr, 10) << endl; cin.get (); retourneer 0;}

3- Vervolgens klikken we met de rechtermuisknop op ons project, het is te vinden aan de rechterkant van onze interface, in de sectie van Oplossingsverkenner. Wij selecteren de Afhankelijkheden opbouwen en later Aanpassingen maken. We doen dit om vast te stellen hoe Visual Studio omgaat met bestanden met de extensie .asmOmdat we niet willen dat de C++-compiler deze bestanden compileert, is ons doel dat VS deze bestanden aanlevert aan: MEER M zodat ik ze assembleer en dan zullen deze bestanden die zijn gekoppeld aan onze C ++ verantwoordelijk zijn voor het vormen van het uiteindelijke uitvoerbare bestand.
4- Om te eindigen met de afhankelijkheden selecteren we de optie van meer M zoals we kunnen zien in de volgende afbeelding:

VERGROTEN

Het is belangrijk om deze stap uit te voeren voordat u bestanden toevoegt met Assembly-code als Visuele studio wijst toe wat een bestand moet doen wanneer het wordt gemaakt en niet wanneer het wordt gebouwd.
5- Dan moeten we nog een C++-bestand toevoegen, maar deze keer met de extensie .asm, voor deze tutorial heb ik het genoemd assembler.asm. Op dezelfde manier kunnen we er elke naam aan geven, behalve main.asm, omdat de compiler problemen kan hebben om te lokaliseren waar uw hoofdmethode zich bevindt.
6- Ons archief assembler.asm Het zal verantwoordelijk zijn voor het berekenen van een reeks numerieke waarden die de kleinste waarde hiervan is en dan C ++ Het zorgt voor het ontvangen van de waarde om het via cout te verwerken, laten we de inhoud van ons bestand bekijken:

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

Dit stelt ons in staat om zowel onze bestanden als onze logica te scheiden. De realisatie van dit soort procedures op basis van 32 bits wordt heel weinig gebruikt, maar het is belangrijk om alle implicaties ervan te kennen, laten we nu kijken hoe we onze code veranderen voor een toepassing van 64 bits evenals de stappen die we moeten nemen om onze omgeving aan te passen Visuele studio.
Visual Studio bevat alle benodigde tools om de native assembly toe te voegen aan ons project in C ++, maar om te werken op basis van 64 bits we moeten wat extra configuraties voor ons project maken, laten we eens kijken:
1- De stappen om dit type codering uit te voeren zijn vergelijkbaar met ons vorige voorbeeld, maar om aan te passen VS we gaan naar de optie Bouwen en wij selecteren Configuratiemanager:

2- In het configuratiebeheerscherm gaan we de optie selecteren Nieuw of nieuw in de platformkolom, die een tweede scherm toont om het projectplatform te selecteren, selecteren we x64 en in de optie Instellingen kopiëren van we verlieten de optie van Win32. Dit zal ervoor zorgen dat VS wijzig versiepaden van 32 bits van MEER M naar die van 64, dus al het werk wordt gedaan door de IDE.

VERGROTEN

3- Zodra dit is gebeurd, kunnen we onze code compileren en uitvoeren, maar we moeten ons bestand aanpassen bijeenkomst aangezien we aan verschillende architecturen werken, laten we eens kijken naar de nieuwe code voor ons bestand:

 ; Lijst: assembler.asm .code; int findMinorNum (int * arr, int count) FindSmallest proc; mov eax, 7ffffffh; cmp edx, 0;jle Afgewerkt; MainLoop: cmp dword ptr [rcx], eax; cmovl eax, dword ptr [rcx]; voeg rcx, 4 toe; dec edx; jnz MainLoop; Afgewerkt: ret; VindKleinste eindp; einde;

Hiermee sluiten we deze tutorial af, we hebben al een eerste blik geworpen op programmeren met bijeenkomst, lijkt het in het begin misschien wat ingewikkeld, maar met een goede beheersing van C ++ en basisbegrippen van machinetaal kunnen we interessante en nuttige dingen bereiken in onze ontwikkelingen.Vond je deze Tutorial leuk en heb je eraan geholpen?Je kunt de auteur belonen door op deze knop te drukken om hem een ​​positief punt te geven