Typer av instruktioner i assemblerspråk: en komplett guide

Informatec Digital » Programmering » Instruktionstyper i assemblerspråk: En komplett guide

Assemblerspråk har varit en av grundpelarna inom mjukvaruutveckling sedan datoranvändningens början. Även om högnivåspråk dominerar scenen idag, är assembler fortfarande allmänt använt och relevant i miljöer där hårdvarukontroll, optimering eller resursbegränsningar är en prioritet.

I den här artikeln ska vi fördjupa oss i olika typer av instruktioner för assemblerspråk, analysera deras struktur, syfte, adresseringslägen och hur de är organiserade i olika arkitekturer. Du hittar också exempel, format och en omfattande översikt som gör att du kan förstå logiken bakom dessa instruktioner, som fungerar mycket nära hårdvaran.

Vad är en instruktion i assemblerspråk?

En assemblerinstruktion är ett kommando som processorn direkt kan förstå (när den väl är översatt till maskinkod av ett assemblerprogram). Varje instruktion har ett specifikt syfte och består vanligtvis av en mnemonik som representerar operationen och en eller flera operander som anger var data hämtas och/eller var resultaten lagras.

Dessa instruktioner är starkt beroende av processorarkitekturen, så varje typ av processor (oavsett om det är x86, ARM, MIPS, bland andra) har sin egen uppsättning instruktioner med specifik syntax och funktioner.

Strukturen av en instruktion

Instruktioner består vanligtvis av två delar:

• Operationskod (opcode): Anger vilken åtgärd som ska utföras, såsom att lägga till, flytta data, jämföra etc.

Operander tillhandahåller den information som krävs för att utföra operationen och kan lagras i register, minne eller vara konstanter. Inte alla instruktioner kräver operander, och i vissa fall kan dessa vara implicita i instruktionen eller lagras i fördefinierade register.

Typer av instruktioner i assemblerspråk

Beroende på vilken funktionalitet de utför inom ett program kan instruktioner för assemblerspråk klassificeras i flera grupper. De mest relevanta beskrivs nedan:

1. Instruktioner för dataöverföring

Dessa instruktioner gör det möjligt att kopiera data från en plats till en annan utan att ändra innehållet vid källan. De är viktiga för att flytta information mellan register, minne och kringutrustning.

Några av de vanligaste instruktionerna i den här gruppen är:

• MOV: Kopierar innehållet i en operand till en annan. Till exempel, MOV AX, BX kopiera innehållet från BX till AX.
• MOVS / MOVSB ​​​​/ MOVSW: Flyttar strängar från en källadress (SI) till en destinationsadress (DI), vilket automatiserar överföringsprocessen.
• LODS / LODSB / LODSW: Laddar ett värde från adressen som anges av SI-registret till ackumulatorn (AL eller AX).
• LÄSA: Laddar en effektiv adress istället för värdet. Användbart för att hämta adressen till en variabel eller struktur.

2. Batteriinstruktioner

Stacken är en LIFO-struktur (sist in, först ut) som används för att tillfälligt lagra data, skicka parametrar eller spara exekveringskontexten.

• SKJUTA PÅ: Lagrar ett värde på stacken och minskar SP-pekaren.
• POP: Hämtar det senaste värdet som lagrats på stacken, vilket ökar SP.
• TRYCK / POPF: De lagrar och hämtar tillståndet för CPU-flaggorna på stacken.

3. Aritmetiska och logiska instruktioner

De gör det möjligt att utföra beräkningar och operationer på bitar. Dessa instruktioner är viktiga för att manipulera numeriska data och fatta beslut i programflödet.

Bland de mest använda hittar vi:

• LÄGG TILL / SUB: Addition och subtraktion.
• MUL / IMUL: Binära multiplikationer.
• DIV / IDIV: Division (heltal eller med tecken).
• OCH / ELLER / XELLER / INTE: Bitvisa logiska operationer.
• SHL / SHR / ROL / ROR: Bitförskjutningar och rotationer.

4. Instruktioner för flödeskontroll

De låter dig modifiera programmets exekveringssekvens , introducera hopp eller villkorliga och ovillkorliga anrop till andra instruktioner.

• JMP: Hoppar ovillkorligt till en annan adress i programmet.
• RING / RET: Anropa en subrutin och returnera.
• JE/JNE/JG/JL/JZ/JNZ: Villkorliga hopp, de utförs om vissa villkor är uppfyllda (efter en jämförelse).

5. Instruktioner för in-/utmatning (I/O)

De möjliggör kommunikation mellan processorn och externa enheter. Dessa instruktioner gör att data kan läsas och skrivas till/från portar (hårdvara).

• IN: Läser data från en ingångsport.
• UT: Skickar data till en utgångsport.

6. Flyttalsinstruktioner

Många processorer har matematiska hjälpprocessorer (eller specialinstruktioner) dedikerade till att arbeta med decimaltal (flyttal). Dessa instruktioner möjliggör operationer som:

• Addition, subtraktion, multiplikation och division av reella tal.
• Trigonometriska operationer (sinus, cosinus, tangent).
• Logaritmiska, exponential- och rotoperationer.

Dessa instruktioner följer vanligtvis IEEE 754-standarden för numerisk precision.

Adresseringslägen

En grundläggande del av instruktionsdesign är hur operandernas plats identifieras. Adresseringslägen definierar hur processorn kommer åt data.

1. Omedelbar adressering

Data inkluderas direkt i instruktionen. Det är snabbt, men det går inte att ändra värden utan att ändra instruktionen.

MOV AX, 5

2. Direkt adressering

Minnesadressen som innehåller data anges explicit.

MOV AX, 

3. Indirekt adressering

Effektivadressen hämtas från innehållet i en post. Mycket flexibel och används för strukturer och länkade listor.

MOV AX, 

4. Indexerad adressering

Adressen beräknas genom att lägga till en bas och ett index (till exempel för att traversera arrayer). Den använder specialregister som SI-, DI- eller bas- + offset-register.

MOV AX, 

Instruktionsformat: olika typer beroende på arkitekturen

Strukturen för en instruktion kan variera beroende på arkitekturen. Vanliga format inkluderar:

4-vägsformat

Den innehåller två operander, en resultatplats och adressen till nästa instruktion. Den är nu föråldrad på grund av sin komplexitet.

3-vägsformat

Den anger två operander och en destinationsadress. Det är vanligt i moderna RISC-arkitekturer.

2-vägsformat

Använd en källoperand och en destinationsoperand (destinationen kan också bidra med värde). Populärt på x86 och andra CISC-arkitekturer.

1-vägsformat

Endast en operand är specificerad; den andra antas vara ackumulatorn. Vanligt i äldre processorer och enkla system.

0-adressformat (stackbaserat)

Operationerna använder stacken för att hämta och lagra operander och resultat. Mycket effektivt för stackbaserade maskiner, såsom vissa programmerbara miniräknare.

Makroinstruktioner och pseudo-opkoder

För att förbättra produktiviteten erbjuder många assemblers makroinstruktioner , som expanderar en enda rad till flera faktiska instruktioner. Dessa är användbara för att undvika att upprepa komplexa mönster eller för att skapa strukturer på hög nivå, såsom loopar eller villkorliga satser.

mycket pseudo-opkoder Det är instruktioner som assemblern internt översätter till en verklig instruktionerföljd. Till exempel, NOP (ingen operation) kan översättas som XCHG AX, AX på x86-processorn.

Assemblerdirektiv

Direktiv ( även kallade pseudooperationer ) är inte instruktioner i strikt bemärkelse. De tjänar till att styra assemblerprocessen, definiera data, kodavsnitt, makron, kompileringsvillkor etc.

Vanliga exempel inkluderar:

• .data / .kod: De anger data- eller kodavsnittet.
• .org: Anger adressen från vilken monteringen ska starta.
• .ekv: Definierar symboliska konstanter.

Användningsfall för assemblerspråk

Trots uppkomsten av högnivåspråk är assemblerspråk fortfarande viktigt inom flera områden:

• Utveckling av inbyggda system och mikrokontroller.
• Programmering av drivrutiner, bootloaders och BIOS.
• Extrem optimering i applikationer som videospel eller kryptografi.
• Omvänd ingenjörskonst, felsökning och lågnivåhackning.

Dessutom har utbildning i assemblerspråk fortfarande en viktig plats inom datavetenskap och elektronik, eftersom det ger en djup förståelse för hur en processor fungerar, hur data lagras och manipuleras, och hur instruktioner exekveras på binär nivå.

Att förstå alla typer av monteringsinstruktioner, deras struktur, funktionalitet och adresseringslägen ger en solid grund för alla programmerare som vill fördjupa sig i lågnivåprogrammering eller förstå hur högnivåspråk i slutändan översätts till maskinkod. Även om dess användning har blivit mer specifik, är det fortfarande ett viktigt verktyg inom flera kritiska områden inom mjukvaru- och systemutveckling.