Hem › FÖRBI › Program på assemblerspråk. Allmänna egenskaper hos kommandosystemet för Assembler-språket för IBM-PC (grundläggande uppsättning kommandon, grundläggande metoder för att adressera operander). Programstruktur i Assembler-språk. Monteringsspråkkommandon

Program på assemblerspråk. Allmänna egenskaper hos kommandosystemet för Assembler-språket för IBM-PC (grundläggande uppsättning kommandon, grundläggande metoder för att adressera operander). Programstruktur i Assembler-språk. Monteringsspråkkommandon

Allmän information om assemblerspråk

Symboliskt assemblerspråk kan i stort sett eliminera nackdelarna med maskinspråksprogrammering.

Dess främsta fördel är att i assemblerspråk presenteras alla programelement i symbolisk form. Att konvertera symboliska kommandonamn till deras binära koder är ansvaret för specialprogram- assembler, som befriar programmeraren från arbetsintensivt arbete och eliminerar de oundvikliga felen.

Symboliska namn som anges vid programmering i assemblerspråk återspeglar vanligtvis programmets semantik, och förkortningen av kommandon återspeglar deras huvudfunktion. Till exempel: PARAM - parameter, TABELL - tabell, MASK - mask, ADD - addition, SUB - subtraktion, etc. etc. Sådana namn är lätta för en programmerare att komma ihåg.

För programmering i assemblerspråk är det nödvändigt att ha komplexa verktyg än för programmering på maskinspråk: du behöver datorsystem baserade på en mikrodator eller PC med en uppsättning kringutrustning(alfanumeriskt tangentbord, teckendisplay, flytenhet och utskriftsenhet), samt inbyggda eller korsprogrammerade system för de erforderliga typerna av mikroprocessorer. Assembly-språk låter dig effektivt skriva och felsöka mycket mer komplexa program än maskinspråk (upp till 1 - 4 KB).

Monteringsspråk är maskinorienterade, d.v.s. beroende av maskinspråket och strukturen för motsvarande mikroprocessor, eftersom varje mikroprocessorinstruktion i dem tilldelas ett specifikt symboliskt namn.

Monteringsspråk ger en betydande ökning av programmerarens produktivitet jämfört med maskinspråk och behåller samtidigt möjligheten att använda alla mjukvarutillgängliga hårdvaruresurser i mikroprocessorn. Detta gör det möjligt för kvalificerade programmerare att skriva program som kan köras på mindre än en kort tid och upptar mindre minne jämfört med program skapade på ett högnivåspråk.

I detta avseende är nästan alla program för att kontrollera inmatnings-/utgångsenheter (drivrutiner) skrivna i assemblerspråk, trots närvaron av ett ganska stort utbud av högnivåspråk.

Med hjälp av assemblerspråk kan programmeraren ställa in följande parametrar:

mnemonics (symboliskt namn) för varje mikroprocessormaskinspråkkommando;

ett standardformat för rader i ett program skrivna på assemblerspråk;

format för att indikera på olika sätt adresserings- och kommandovarianter;

format för att specificera teckenkonstanter och heltalskonstanter i olika talsystem;

pseudo-kommandon som styr processen att sätta ihop (översätta) ett program.

I assemblerspråk skrivs ett program rad för rad, det vill säga en rad tilldelas för varje kommando.

För mikrodatorer byggda på basis av de vanligaste typerna av mikroprocessorer kan det finnas flera varianter av assemblerspråk, men vanligtvis används en flitigt i praktiken - detta är det så kallade standard assemblerspråket

Programmering på maskininstruktionsnivå är den lägsta nivån på vilken program kan skrivas. Systemet med maskininstruktioner måste vara tillräckligt för att genomföra de nödvändiga åtgärderna genom att utfärda instruktioner till datorhårdvaran.

Varje maskinkommando består av två delar:

· operationssal - bestämma "vad man ska göra";

· operand - definierar bearbetningsobjekt, "vad man ska göra med".

Kommandot för mikroprocessormaskin, skrivet i assemblerspråk, är en rad med följande syntaktiska form:

etikett kommando/direktiv operand(er) ;kommentarer

I det här fallet är det obligatoriska fältet på raden ett kommando eller direktiv.

Etiketten, kommandot/direktivet och operander (om några) är åtskilda av minst ett mellanslag eller tabbtecken.

Om ett kommando eller direktiv behöver fortsätta på nästa rad, används ett omvänt snedstreck: \.

Som standard skiljer inte assemblerspråk mellan stora och små bokstäver när du skriver kommandon eller direktiv.

Direkt adressering: Den effektiva adressen bestäms direkt av maskininstruktionens offsetfält, som kan vara 8, 16 eller 32 bitar stort.

mov eax, summa ; eax = summa

Samlaren ersätter summa med motsvarande adress lagrad i datasegmentet (adresserad av ds-registret som standard) och placerar värdet som lagrats på summa i eax-registret.

Indirekt adressering har i sin tur följande typer:

· indirekt grundläggande (register) adressering;

· indirekt grundläggande (register) adressering med offset;

· indirekt indexadressering;

· indirekt grundläggande indexadressering.

Indirekt grundläggande (register) adressering. Med denna adressering kan den effektiva adressen för operanden lokaliseras i vilket som helst av de allmänna registren, förutom sp/esp och bp/ebp (dessa är specifika register för att arbeta med stacksegmentet). Syntaktisk i ett kommando uttrycks detta adresseringsläge genom att innesluta registernamnet i hakparentes.

mov eax, ; eax = *esi; *esi-värde vid adress esi

Introduktion.

Språk som det är skrivet på originalprogram, ringde ingång språk, och språket till vilket det översätts för exekvering av processorn är på lediga dagar tunga. Processen att konvertera inmatningsspråk till utdataspråk kallas utsända. Eftersom processorer kan köra program i binärt maskinspråk, som inte används för programmering, är översättning av alla källprogram nödvändig. Känd två sätt sändningar: sammanställning och tolkning.

På kompilering källprogrammet översätts först fullständigt till ett motsvarande program i utmatningsspråket, kallat objekt program och sedan körs. Denna process genomförs med hjälp av en speciell program, kallad kompilator. En kompilator för vilken inmatningsspråket är en symbolisk form för att representera maskinspråket (utgångsspråket) för binära koder kallas assemblerare.

På tolkningar Varje textrad i källprogrammet analyseras (tolkas) och kommandot som anges i det exekveras omedelbart. Genomförandet av denna metod anförtros tolkprogram. Tolkning tar lång tid. För att öka dess effektivitet, istället för att bearbeta varje rad, konverterar tolken först alla team strängar till tecken (

). Den genererade sekvensen av symboler används för att utföra de funktioner som tilldelats det ursprungliga programmet.

Monteringsspråket som diskuteras nedan implementeras med hjälp av kompilering.

Språkets egenskaper.

Huvuddragen hos montören:

● istället för binära koder använder språket symboliska namn - mnemonics. Till exempel, för additionskommandot (

) mnemonics används

Subtraktioner (

multiplikation (

divisioner (

etc. Symboliska namn används också för att adressera minnesceller. För att programmera i assemblerspråk, istället för binära koder och adresser, behöver du bara känna till symboliska namn som assemblern översätter till binära koder;

● varje påstående motsvarar ett maskinkommando(kod), d.v.s. det finns en en-till-en-överensstämmelse mellan maskinkommandon och operatörer i ett assemblerprogram;

● språk ger åtkomst till alla föremål och team. Språk på hög nivå har inte denna förmåga. Till exempel låter assemblerspråk dig kontrollera bitar av flaggregistret och högnivåspråk (till exempel,

) har inte denna förmåga. Observera att systemprogrammeringsspråk (till exempel C) ofta upptar en mellanposition. När det gäller tillgänglighet ligger de närmare assemblerspråk, men har syntaxen som ett språk på hög nivå;

● assemblerspråk är inte ett universellt språk. Varje specifik grupp av mikroprocessorer har sin egen assembler. Språk på hög nivå har inte denna nackdel.

Till skillnad från högnivåspråk tar det mycket tid att skriva och felsöka ett program på assemblerspråk. Trots detta har monteringsspråk fått bred användning på grund av följande omständigheter:

● ett program skrivet på assemblerspråk är betydligt mindre i storlek och körs mycket snabbare än ett program skrivet på ett högnivåspråk. För vissa tillämpningar spelar dessa indikatorer en primär roll, till exempel många systemprogram(inklusive kompilatorer), program på kreditkort, mobiltelefoner, enhetsdrivrutiner, etc.;

● vissa procedurer kräver full tillgång till hårdvaran, vilket vanligtvis är omöjligt att göra på ett högnivåspråk. Detta fall inkluderar avbrott och avbrottshanterare i operativsystem, såväl som enhetskontroller i inbyggda realtidssystem.

I de flesta program är endast en liten andel av den totala koden ansvarig för en stor andel av programmets körningstid. Vanligtvis är 1 % av programmet ansvarigt för 50 % av exekveringstiden och 10 % av programmet ansvarar för 90 % av exekveringstiden. Därför, för att skriva ett specifikt program under verkliga förhållanden, används både assembler och ett av högnivåspråken.

Operatörsformat i assemblerspråk.

Ett assemblerspråksprogram är en lista med kommandon (påståenden, meningar), som vart och ett upptar en separat rad och innehåller fyra fält: ett etikettfält, ett operationsfält, ett operandfält och ett kommentarsfält. Varje fält har en separat kolumn.

Etikettfält.

Kolumn 1 är tilldelad för etikettfältet. Etiketten är ett symboliskt namn, eller identifierare, adresser minne. Det är nödvändigt så att du kan:

● gör en villkorlig eller ovillkorlig övergång till kommandot;

● få tillgång till platsen där data lagras.

Sådana uttalanden är försedda med en etikett. För att ange ett namn används (versaler) bokstäver i det engelska alfabetet och siffror. Namnet måste ha en bokstav i början och en kolonavgränsare i slutet. Kolonetiketten kan skrivas på en separat rad, och opkoden kan skrivas på nästa rad i kolumn 2, vilket förenklar kompilatorns arbete. Frånvaron av ett kolon tillåter inte att skilja en etikett från en operationskod om de är placerade på separata rader.

I vissa versioner av assemblerspråk placeras kolon endast efter instruktionsetiketter, inte efter dataetiketter, och etikettens längd kan vara begränsad till 6 eller 8 tecken.

Det bör inte finnas identiska namn i etikettfältet, eftersom etiketten är associerad med kommandoadresser. Om det inte finns något behov av att anropa ett kommando eller data från minnet under programexekveringen, förblir etikettfältet tomt.

Driftkodfält.

Det här fältet innehåller minneskoden för ett kommando eller pseudokommando (se nedan). Kommandot mnemonisk kod väljs av språkutvecklarna. På assemblerspråk

mnemonic väljs för att ladda ett register från minnet

), och för att spara innehållet i registret i minnet - ett minnesminne

). På assemblerspråk

för båda operationerna kan du använda samma namn, respektive

Om valet av mnemoniska namn kan vara godtyckligt, bestäms behovet av att använda två maskininstruktioner av processorarkitekturen

Mnemoniken för register beror också på assemblerversionen (tabell 5.2.1).

Operandfält.

Här ligger ytterligare information, nödvändig för att utföra operationen. I operandfältet för hoppkommandon anges adressen till vilken hoppet behöver göras, samt adresser och register som är operander för maskinkommandot. Som ett exempel ger vi operander som kan användas för 8-bitars processorer

● numeriska data,

presenteras i olika nummersystem. För att ange vilket talsystem som används följs konstanten av en av latinska bokstäver: I,

Följaktligen, binära, oktala, hexadecimala, decimala talsystem (

Du behöver inte skriva ner det). Om den första siffran i ett hexadecimalt tal är A, B, C,

Sedan läggs en obetydlig 0 (noll) till framför;

● koder för interna mikroprocessorregister och minnesceller

M (källor eller mottagare av information) i form av bokstäverna A, B, C,

M eller deras adresser i valfritt nummersystem (till exempel 10B - registeradress

i binärt system);

● identifierare,

för registerpar av flygplan,

De första bokstäverna är B,

N; för ett par ackumulator- och funktionsregister -

; för programräknaren -

;för stackpekaren -

● etiketter som anger adresserna till operanderna eller nästa instruktioner i villkoret

(om villkoret är uppfyllt) och ovillkorliga övergångar. Till exempel operand M1 i kommandot

betyder behovet av en ovillkorlig övergång till kommandot, vars adress i etikettfältet är markerad med identifieraren M1;

● uttryck,

som är konstruerade genom att länka data som diskuterats ovan med hjälp av aritmetiska och logiska operatorer. Observera att metoden för att reservera datautrymme beror på språkversionen. Assembly språkutvecklare för

Definiera ordet) och angavs senare Alternativt alternativ.

som var på språket för processorer från allra första början

I språkversion

Begagnade

Definiera en konstant).

Processorer bearbetar operander av olika längd. För att definiera det tog assemblerutvecklare olika beslut, till exempel:

II-register av olika längd har olika namn: EAX - för att placera 32-bitars operander (typ

); AX - för 16-bitars (typ

och AN - för 8-bitars (typ

● för processorer

Suffix läggs till i varje operationskod: suffix

För typ

; suffix ".B" för typ

olika opkoder används för operander av olika längd, till exempel för att ladda en byte, halvord (

) och ord i ett 64-bitars register med hjälp av opkoder

respektive.

Kommentarsfält.

Det här fältet ger förklaringar om programmets åtgärder. Kommentarer påverkar inte programmets funktion och är avsedda för människor. De kan behövas för att modifiera ett program, som utan sådana kommentarer kan vara helt obegripligt även för erfarna programmerare. En kommentar börjar med en symbol och används för att förklara och dokumentera program. Startkaraktären för en kommentar kan vara:

● semikolon (;) på språk för företagets processorer

● Utropstecken(!) på språk för

Varje separat kommentarsrad föregås av en inledande karaktär.

Pseudo-kommandon (direktiv).

I assemblerspråk finns det två huvudtyper av kommandon:

● grundläggande instruktioner som motsvarar processorns maskinkod. Dessa kommandon utför all bearbetning som programmet avser;

● pseudo-kommandon eller direktiv, utformad för att betjäna processen att översätta ett program till ett kodkombinationsspråk. Som exempel i tabellen. 5.2.2 visar några pseudo-kommandon från assemblern

för familjen

Vid programmering finns det situationer då, enligt algoritmen, samma kedja av kommandon måste upprepas många gånger. För att komma ur den här situationen kan du:

● skriv den önskade sekvensen av kommandon när den visas. Detta tillvägagångssätt leder till en ökning av programmets volym;

● ordna denna sekvens i en procedur (subrutin) och anropa den vid behov. Denna utgång har sina nackdelar: varje gång du måste utföra ett speciellt proceduranropskommando och ett returkommando, som, om sekvensen är kort och ofta används, kan avsevärt minska programmets hastighet.

Den enklaste och effektiv metod upprepad upprepning av en kedja av kommandon består av att använda makro, som kan representeras som ett pseudokommando utformat för att omöversätta en grupp kommandon som ofta finns i ett program.

Ett makro, eller makrokommando, kännetecknas av tre aspekter: makrodefinition, makroinversion och makroextension.

Makro definition

Detta är en beteckning för en upprepad sekvens av programkommandon, som används för referenser i programtexten.

Makrodefinitionen har följande struktur:

Lista över uttryck; Makro definition

I den givna strukturen för makrodefinition kan tre delar särskiljas:

● titel

makro, inklusive namnet

Pseudo-kommando

och en uppsättning parametrar;

● markerad med prickar kropp makro;

● team

gradering

makrodefinitioner.

Makrodefinitionsparameteruppsättningen innehåller en lista över alla parametrar som anges i operandfältet för den valda gruppen av instruktioner. Om dessa parametrar angavs tidigare i programmet, behöver de inte anges i makrodefinitionshuvudet.

För att åter sammanställa den valda gruppen av kommandon, används en överklagande som består av namnet

makrokommandon och lista över parametrar med andra värden.

När assemblern stöter på en makrodefinition under kompileringsprocessen, lagrar den den i makrodefinitionstabellen. Vid efterföljande framträdanden i programmet för namnet (

) för ett makro, ersätter assemblern det med makrots brödtext.

Att använda ett makronamn som opkod kallas makroomvändning(makroanrop), och ersätt det med makrots kropp - makroexpansion.

Om ett program representeras som en sekvens av tecken (bokstäver, siffror, mellanslag, skiljetecken och vagnreturer för att flytta till en ny rad), så består makroexpansion av att ersätta vissa kedjor från denna sekvens med andra kedjor.

Makroexpansion sker under monteringsprocessen, inte under programkörning. Metoder för att manipulera teckensträngar tilldelas makro betyder.

Monteringsprocessen genomförs i två omgångar:

● Vid första passet bevaras alla makrodefinitioner och makroanrop utökas. I detta fall läses det ursprungliga programmet och konverteras till ett program där alla makrodefinitioner tas bort, och varje makroanrop ersätts av makrots kropp;

● det andra passet bearbetar det resulterande programmet utan makron.

Makron med parametrar.

För att arbeta med upprepade sekvenser av kommandon, vars parametrar kan ha olika värden, tillhandahålls makrodefinitioner:

● med faktisk parametrar som placeras i operandfältet för makroanropet;

● med formell parametrar. Under makroexpansion ersätts varje formell parameter som visas i makrot med motsvarande faktiska parameter.

använda makron med parametrar.

Program 1 innehåller två liknande sekvenser av kommandon, som skiljer sig åt genom att den första byter P och

Och den andra

Program 2 innehåller ett makro med två formella parametrar P1 och P2. Under makroexpansion ersätts varje P1-tecken i makrokroppen med den första faktiska parametern (P,

), och symbolen P2 ersätts av den andra faktiska parametern (

) från program nr 1. I makroanropet

program 2 är märkt: P,

Den första faktiska parametern,

Andra faktiska parametern.

Program 1

Program 2

MOV EBX,Q MOV EAX,Pl

MOV Q,EAX MOV EBX,P2

MOV P,EBX MOV P2,EAX

Utökade möjligheter.

Låt oss titta på några avancerade språkfunktioner

Om ett makro som innehåller ett villkorligt hoppkommando och en etikett som ska hoppa till anropas två eller flera gånger, kommer etiketten att dupliceras (problem med dubbletter av etiketter), vilket kommer att orsaka ett fel. Därför tilldelar varje anrop en separat etikett som en parameter (av programmeraren). På språket

etiketten deklareras lokal (

) och tack vare avancerade funktioner genererar assemblern automatiskt en annan etikett varje gång makrot expanderas.

låter dig definiera makron i andra makron. Denna avancerade funktion är mycket användbar i kombination med villkorlig länkning av ett program. Låt oss överväga

IF WORDSIZE GT 16 M2 MAKRO

M2-makrot kan definieras i båda delarna av satsen

Definitionen beror dock på vilken processor programmet är monterat på: 16-bitars eller 32-bitars. Om M1 inte anropas kommer makro M2 inte att definieras alls.

En annan avancerad funktion är att makron kan anropa andra makron, inklusive sig själva - rekursiv ring upp. I det senare fallet, för att undvika en oändlig loop, måste makrot skicka en parameter till sig själv som ändras med varje expansion, och även kolla upp denna parameter och avsluta rekursionen när parametern når ett visst värde.

Om användningen av makromedel i assembler.

När du använder makron måste assemblern kunna utföra två funktioner: spara makrodefinitioner Och utöka makroutmaningar.

Spara makrodefinitioner.

Alla makronamn lagras i en tabell. Varje namn åtföljs av en pekare till motsvarande makro så att det kan anropas vid behov. Vissa montörer har en separat tabell för makronamn, andra har en generell tabell där, tillsammans med makronamn, alla maskininstruktioner och direktiv finns.

När du stöter på ett makro under montering är skapad:

● nytt bordselement med namnet på makrot, antalet parametrar och en pekare till en annan makrodefinitionstabell där makrots brödtext kommer att lagras;

● lista formell parametrar.

Makrokroppen, som helt enkelt är en sträng av tecken, läses sedan och lagras i makrodefinitionstabellen. Formella parametrar som förekommer i slingans kropp är markerade speciell karaktär.

Intern representation av ett makro

från exemplet ovan för program 2 (sid. 244) är:

MOV EAX, MOV EBX, MOV MOV &

där semikolon används som vagnreturtecknet och et-tecken & används som det formella parametertecknet.

Utöka makrosamtal.

Närhelst en makrodefinition påträffas under monteringen lagras den i makrotabellen. När ett makro anropas, slutar assemblern tillfälligt att läsa indata från inmatningsenheten och börjar läsa den lagrade makrokroppen. De formella parametrarna som extraherats från makrokroppen ersätts av faktiska parametrar och tillhandahålls av anropet. Parametrarna &-tecken & före gör att assemblern kan känna igen dem.

Trots att det finns många versioner av assembler har monteringsprocesserna gemensamma drag och är lika på många sätt. Driften av en två-pass assembler diskuteras nedan.

Två-pass assembler.

Ett program består av ett antal påståenden. Därför verkar det som att när du monterar kan du använda följande sekvens av åtgärder:

● översätta det till maskinspråk;

● överföra den resulterande maskinkoden till en fil och motsvarande del av listningen till en annan fil;

● upprepa de angivna procedurerna tills hela programmet är översatt.

Detta tillvägagångssätt är dock inte effektivt. Ett exempel är det så kallade problemet framåt länk. Om den första satsen är ett hopp till sats P, som finns i slutet av programmet, kan assembleraren inte översätta den. Han måste först fastställa adressen till operatören P, och för att göra detta måste han läsa hela programmet. Varje fullständig läsning av källprogrammet kallas textavsnitt. Låt oss visa hur du kan lösa lookahead-länkproblemet med två pass:

● vid första passet bör du samla och lagra alla symboldefinitioner (inklusive etiketter) i tabellen, och vid den andra passagen, läs och sätt ihop varje operatör. Denna metod är relativt enkel, men en andra passage genom det ursprungliga programmet kräver ytterligare tid som spenderas på I/O-operationer;

● vid första passet ska du konvertera programmet i en mellanform och spara det i en tabell, och utför det andra passet inte enligt det ursprungliga programmet, utan enligt tabellen. Denna sammansättningsmetod sparar tid, eftersom det andra passet inte utför I/O-operationer.

Första passet.

Första passningsmålet- bygga ett symbolbord. Som nämnts ovan är ett annat mål med det första passet att bevara alla makrodefinitioner och utöka anrop när de visas. Följaktligen sker både symboldefinition och makroexpansion i en gång. Symbolen kan vara antingen märka, eller menande, som ett specifikt namn tilldelas med -you-direktivet:

;Värde - buffertstorlek

Genom att tilldela betydelse till symboliska namn i kommandoetikettfältet, specificerar assemblern i huvudsak adresserna som varje kommando kommer att ha under programexekveringen. För detta ändamål lagrar montören under monteringsprocessen instruktionsadressräknare(

) som en speciell variabel. I början av det första passet sätts värdet på specialvariabeln till 0 och inkrementeras efter varje kommando som bearbetas med längden på det kommandot. Som exempel i tabellen. 5.2.3 visar ett programfragment som anger längden på kommandon och räknarvärden. Vid första passet genereras tabeller symboliska namn, direktiv Och operationskoder, och vid behov bokstavlig tabell. En literal är en konstant som assembleraren automatiskt reserverar minne för. Låt oss omedelbart notera att moderna processorer innehåller instruktioner med omedelbara adresser, så deras sammanställare stöder inte bokstavliga ord.

Symbol Namn Tabell

innehåller ett element för varje namn (tabell 5.2.4). Varje element i den symboliska namntabellen innehåller själva namnet (eller en pekare till det), dess numeriska värde och ibland ytterligare information, som kan inkludera:

● längden på datafältet som är associerat med symbolen;

● minnesomfördelningsbitar (som indikerar om värdet på en symbol ändras om programmet laddas på en annan adress än assemblern avsett);

● information om huruvida symbolen kan nås utanför proceduren.

Symboliska namn är etiketter. De kan specificeras med operatorer (t.ex.

Direktivtabell.

Den här tabellen listar alla direktiv, eller pseudo-kommandon, som påträffas vid sammansättning av ett program.

Driftkodtabell.

För varje operationskod har tabellen separata kolumner: operationskodsbeteckning, operand 1, operand 2, hexadecimalt värde för operationskoden, kommandolängd och kommandotyp (tabell 5.2.5). Operationskoder är indelade i grupper beroende på antal och typ av operander. Kommandotypen bestämmer gruppnumret och specificerar proceduren som anropas för att bearbeta alla kommandon i den gruppen.

Andra passet.

Mål för andra passet- skapande av ett objektprogram och utskrift, vid behov, av monteringsprotokollet; mata ut information som krävs för att länken ska länka procedurer som samlades vid olika tidpunkter till en körbar fil.

I det andra passet (som i det första) läses och bearbetas raderna som innehåller påståendena en efter en. Den ursprungliga operatorn och utdataoperatorn härledda från den i hexadecimal objekt Koden kan skrivas ut eller läggas i en buffert för senare utskrift. Efter återställning av kommandoadressräknaren anropas kommandot nästa uttalande.

Källprogrammet kan innehålla fel, till exempel:

● den givna symbolen är inte definierad eller definieras mer än en gång;

● op-koden representeras av ett ogiltigt namn (på grund av ett stavfel), har inte tillräckligt med operander eller har för många operander;

● ingen operatör

Vissa montörer kan upptäcka en odefinierad symbol och ersätta den. Men i de flesta fall, när den stöter på en felsats, visar assemblern ett felmeddelande på skärmen och försöker fortsätta monteringsprocessen.

Artiklar dedikerade till assemblerspråk.

Ämne 2.5 Grunderna i processorprogrammering

När programmets längd ökar, blir det allt svårare att komma ihåg koderna för olika operationer. Mnemonics ger viss hjälp i detta avseende.

Det symboliska kommandokodningsspråket kallas assemblerare.

assembleringsspråkär ett språk där varje yttrande motsvarar exakt ett maskinkommando.

hopsättning kallas att konvertera ett program från assemblerspråk, d.v.s. förbereda ett program på maskinspråk genom att ersätta symboliska namn på operationer med maskinkoder och symboliska adresser med absoluta eller relativa tal, samt införliva biblioteksprogram och generera sekvenser av symboliska instruktioner genom att specificera specifika parametrar i mikroteam. Det här programmet vanligtvis placerad i ROM eller inmatad i RAM från något externt medium.

Assembly språk har flera funktioner som skiljer det från högnivåspråk:

1. Detta är en en-till-en-överensstämmelse mellan assembly-språkpåståenden och maskininstruktioner.

2. En programmerare för assemblerspråk har tillgång till alla objekt och instruktioner som finns på målmaskinen.

Att förstå grunderna för programmering i maskinorienterade språk är användbart för:

Bättre förståelse för PC-arkitektur och mer kompetent användning av datorer;

Att utveckla mer rationella strukturer av algoritmer för program för att lösa tillämpade problem;

Möjligheten att visa och korrigera körbara program med tilläggen .exe och .com, kompilerade från alla högnivåspråk, i händelse av förlust av källprogrammen (genom att anropa de angivna programmen i DEBUG-programmets debugger och dekompilera deras visning i assembly språk);

Sammanställning av program för att lösa de mest kritiska problemen (ett program skrivet på ett maskinorienterat språk är vanligtvis mer effektivt - kortare och snabbare med 30-60 procent av programmen som erhålls som ett resultat av översättning från högnivåspråk)

Att implementera procedurer som ingår i huvudprogrammet i form av separata fragment i händelse av att de inte kan implementeras vare sig på det högnivåspråk som används eller med OS-tjänstprocedurer.

Ett program i assemblerspråk kan bara köras på en familj av datorer, medan ett program skrivet på ett högnivåspråk potentiellt kan köras på olika maskiner.

Assembly-språkalfabetet består av ASCII-tecken.

Tal är bara heltal. Det finns:

Binära tal slutar med bokstaven B;

Decimaltal som slutar med bokstaven D;

Hexadecimala tal slutar med bokstaven H.

RAM, register, datapresentation

För en viss serie riksdagsledamöter används ett individuellt programmeringsspråk - assemblerspråk.

Assembly språk intar en mellanposition mellan maskinkoder och högnivåspråk. Programmering på detta språk är lättare. Ett program i assemblerspråk gör en effektivare användning av kapaciteten hos en specifik maskin (närmare bestämt en MP) än ett program på ett högnivåspråk (vilket är enklare för en programmerare än assembler). Låt oss titta på de grundläggande principerna för programmering i maskinorienterade språk med hjälp av exemplet på monteringsspråk för MP KR580VM80. En generell metod används för att programmera i språket. Specifika tekniska tekniker för inspelning av program är förknippade med funktionerna i arkitekturen och kommandosystemet för mål-MP.

Mjukvarumodell mikroprocessorsystem baserat på MP KR580VM80

Mjukvarumodell av MPS i enlighet med figur 1

MP-portar minne

A.C.

Bild 1

Ur programmerarens synvinkel har MP KR580VM80 följande programtillgängliga register.

A– 8-bitars ackumulatorregister. Det är MP:s huvudregister. Varje operation som utförs i en ALU innebär att en av operanderna som ska behandlas placeras i ackumulatorn. Resultatet av en operation i ALU lagras också vanligtvis i A.

B, C, D, E, H, L– 8-bitars register för allmänna ändamål (GPR). Inre minne MP. Designad för att lagra bearbetad information, såväl som resultatet av operationen. Vid bearbetning av 16-bitars ord bildar register paren BC, DE, HL, och dubbelregistret kallas första bokstaven - B, D, H. I ett registerpar är det högsta det första registret. Register H och L har en speciell egenskap, som används både för att lagra data och för att lagra 16-bitars adresser för RAM-celler.

FL– flaggregister (teckenregister) 8-bitars register i vilket fem tecken på resultatet av att utföra aritmetiska och logiska operationer i MP lagras. FL-format enligt bilden

Bit C (CY - bär) - bär, satt till 1 om det fanns en bäring från bytens höga ordning vid utförande av aritmetiska operationer.

Bit P (paritet) – paritet, satt till 1 om antalet ettor i bitarna i resultatet är jämnt.

AC-siffran är en extra överföring, utformad för att lagra överföringsvärdet från den låga ordningens tetrad av resultatet.

Bit Z (noll) – sätt till 1 om resultatet av operationen är 0.

Bit S (tecken) – sätts till 1 om resultatet är negativt och till 0 om resultatet är positivt.

SP– stackpekare, ett 16-bitars register, utformat för att lagra adressen till minnescellen där den sista byten som infogades i stacken skrevs.

RS– programräknare (programräknare), ett 16-bitars register, utformat för att lagra adressen till nästa instruktion som ska utföras. Innehållet i programräknaren ökas automatiskt med 1 omedelbart efter att nästa instruktionsbyte hämtats.

Det initiala minnesområdet med adress 0000Н – 07FF innehåller kontrollprogrammet och demonstrationsprogram. Detta är ROM-området.

0800 – 0AFF - adressområde för inspelning av de program som studeras. (BAGGE).

0В00 – 0ВВ0 - adressområde för att skriva data. (BAGGE).

0ВВ0 är startadressen för stacken. (BAGGE).

En stack är ett speciellt organiserat område av RAM avsett för tillfällig lagring av data eller adresser. Det sista numret som skrivs till stacken visas först. Stackpekaren lagrar adressen för den sista stackcellen i vilken informationen skrivs. När en subrutin anropas lagras returadressen till huvudprogrammet automatiskt i stacken. Som regel sparas i början av varje subrutin innehållet i alla register som är involverade i dess exekvering i stacken, och i slutet av subrutinen återställs de från stacken.

Dataformat och kommandostruktur för assemblerspråk

Minnet i MP KR580VM80 är en array av 8-bitars ord som kallas bytes. Varje byte har sin egen 16-bitars adress, som bestämmer dess position i sekvensen av minnesceller. MP kan adressera 65536 byte minne, som kan finnas i både ROM och RAM.

Dataformat

Data lagras i minnet som 8-bitars ord:

D7 D6 D5 D4 D3 D2 D1 D0

Den minst signifikanta biten är bit 0, den mest signifikanta biten är bit 7.

Ett kommando kännetecknas av dess format, det vill säga antalet bitar som tilldelats för det, vilka är uppdelade byte-för-byte i vissa funktionella fält.

Kommandoformat

MP KR580VM80-kommandon har ett, två eller tre byte-format. Multibyte-kommandon måste placeras på angränsande språk. Kommandoformatet beror på detaljerna för den operation som utförs.

Den första byten av kommandot innehåller operationskoden, skriven i mnemonisk form.

Det bestämmer kommandoformatet och de åtgärder som måste utföras av MP på data under dess exekvering, och adresseringsmetoden, och kan även innehålla information om var datat finns.

Den andra och tredje byten kan innehålla data på vilka operationer utförs, eller adresser som indikerar platsen för data. De data på vilka åtgärder utförs kallas operander.

Single-byte kommandoformat enligt figur 2

Figur 4

I assemblerspråkkommandon har operationskoden en förkortad form för att skriva engelska ord - en mnemonisk notation. Mnemonics (från grekiskans mnemonics - konsten att memorera) gör det lättare att komma ihåg kommandon genom deras funktionella syfte.

Före körning översätts källprogrammet med hjälp av ett översättningsprogram som kallas assembler till språket för kodkombinationer - maskinspråk, i denna form placeras det i MP:ns minne och används sedan när kommandot utförs.

Adresseringsmetoder

Alla operandkoder (ingång och utgång) måste finnas någonstans. De kan placeras i MP:s interna register (den mest bekväma och snabbt alternativ). De kan placeras i system minne(det vanligaste alternativet). Slutligen kan de placeras i I/O-enheter (det sällsynta fallet). Placeringen av operanderna bestäms av instruktionskoden. Existera olika metoder, med vilken instruktionskoden kan bestämma var ingångsoperanden ska tas och var utgångsoperanden ska placeras. Dessa metoder kallas adresseringsmetoder.

För MP KR580VM80 finns följande adresseringsmetoder:

Direkt;

Registrera;

Indirekt;

Staplad.

Direkt adressering förutsätter att (ingångs)operanden finns i minnet omedelbart efter instruktionskoden. Operaanden är vanligtvis en konstant som måste skickas någonstans, läggas till något, etc. data finns i den andra eller andra och tredje byten av kommandot, med den låga byten av data placerad i den andra byten av kommandot, och den höga byten i den tredje kommandobyten.

Hetero (aka absolut) adressering förutsätter att operanden (ingång eller utgång) finns i minnet på adressen, vars kod finns inuti programmet omedelbart efter instruktionskoden. Används i tre-byte-kommandon.

Registrera adressering förutsätter att operanden (ingång eller utgång) finns i MP:ns interna register. Används i enkelbyte-kommandon

Indirekt (implicit) adressering förutsätter att MP:ns interna register inte innehåller själva operanden utan dess adress i minnet.

Stack adressering förutsätter att kommandot inte innehåller en adress. Adressering av minnesceller med hjälp av innehållet i 16-bitars SP-registret (stackpekare).

Kommandosystem

MP-kommandosystemet är en komplett lista över elementära åtgärder som MP kan utföra. MP som styrs av dessa kommandon utför enkla åtgärder, såsom elementära aritmetiska och logiska operationer, dataöverföring, jämförelse av två värden, etc. Antalet kommandon för MP KR580VM80 är 78 (med hänsyn tagen till modifieringar 244).

Följande grupper av kommandon särskiljs:

Dataöverföring;

Aritmetisk;

Hjärngymnastik;

Hoppa kommandon;

In-/utgångs-, kontroll- och stackkommandon.

Symboler och förkortningar som används när man beskriver kommandon och komponerar program

Symbol	Minskning
ADDR	16-bitars adress
DATA	8-bitars data
DATA 16	16-bitars data
HAMN	8-bitars I/O-enhetsadress
BYTE 2	Andra byte av kommandot
BYTE 3	Tredje kommandobyte
R, Rl, R2	Ett av registren: A, B, C, D, E, H, L
R.P.	Ett av registerparen: B - specificerar paret BC; D - specificerar ett DE-par; H – anger HL-paret
RH	Första registret av paret
R.L.	Andra register av paret
Λ	Logisk multiplikation
V	Logiskt tillägg
	Tillägg modulo två
M	En minnescell vars adress specificerar innehållet i registerparet HL, dvs M = (HL)

1. PC-arkitektur………………………………………………………………………………………5

1.1. Register.

1.1.1 Register för allmänna ändamål.

1.1.2. Segmentregister

1.1.3 Flaggregister

1.2. Organisation av minnet.

1.3. Datapresentation.

1.3.1 Datatyper

1.3.2 Representation av tecken och strängar

2. Programförklaringar i assembler …………………………………………

Monteringsspråkkommandon

2.2. Adresseringslägen och maskininstruktionsformat

3. Pseudooperatörer……………………………………………………………….

3.1 Datadefinitionsdirektiv

3.2 Struktur för ett assemblerprogram

3.2.1 Programsegment. anta direktiv

3.2.3 Förenklat segmenteringsdirektiv

4. Sammansättning och sammansättning av programmet ………………………….

5. Dataöverföringskommandon……………………………………………………….

5.1 Allmänna kommandon

5.2 Stapla kommandon

5.3 I/O-kommandon

5.4 Kommandon för vidarebefordran av adress

5.5 Flagga vidarebefordran kommandon

6. Aritmetiska kommandon………………………………………………….

6.1 Aritmetiska operationer på binära heltal

6.1.1 Addition och subtraktion

6.1.2 Kommandon för att öka och minska mottagaren med ett

6.2 Multiplikation och division

6.3 Byte av tecken

7. Logiska operationer……………………………………………………….

8. Växlingar och cykliska växlingar………………………………………………………………

9. Strängoperationer……………………………………………………………….

10. Logik och organisation av program…………………………………………

10.1 Ovillkorliga hopp

10.2 Villkorliga hopp

10.4 Rutiner på assemblerspråk

10.5 INT-avbrott

10.6 Systemprogramvara

10.6.1.1 Läsa tangentbordet.

10.6.1.2 Visa tecken på skärmen

10.6.1.3 Avsluta program.

10.6.2.1 Välja visningslägen

11. Diskminne………………………………………………………………………..

11.2 Fildistributionstabell

11.3 Disk I/O-operationer

11.3.1 Skriva en fil till disk

11.3.1.1 ASCIIZ-data

11.3.1.2 Filnummer

11.3.1.3 Skapa en diskfil

11.3.2 Läsa en diskfil

Introduktion

Monteringsspråk är en symbolisk representation av maskinspråk. Alla processer i en persondator (PC) på den lägsta hårdvarunivån drivs endast av maskinspråkkommandon (instruktioner). Det är omöjligt att verkligen lösa problem relaterade till hårdvara (eller till och med, dessutom beroende av hårdvara, som att öka hastigheten på ett program), utan kunskap om assembler.

Assembleren är en bekväm form av kommandon direkt för PC-komponenter och kräver kunskap om egenskaperna och förmågorna hos den integrerade kretsen som innehåller dessa komponenter, nämligen PC-mikroprocessorn. Således är assemblerspråk direkt relaterat till den interna organisationen av PC:n. Och det är ingen slump att nästan alla språkkompilatorer på hög nivå stöder åtkomst till assemblernivån för programmering.

En del av utbildningen av en professionell programmerare är nödvändigtvis studiet av assembler. Detta beror på att programmering av assemblerspråk kräver kunskap om PC-arkitektur, vilket gör att du kan skapa mer effektiva program på andra språk och kombinera dem med assemblerprogram.

Manualen diskuterar programmering i assemblerspråk för datorer baserade på Intels mikroprocessorer.

Den här handledningen vänder sig till alla som är intresserade av processorarkitektur och grunderna i programmering i Assembly-språk, främst till utvecklare av mjukvaruprodukt.

PC-arkitektur.

Datorarkitektur är en abstrakt representation av en dator, som återspeglar dess strukturella, kretsar och logiska organisation.

Alla moderna datorer har några gemensamma och individuella arkitektoniska egenskaper. Enskilda egenskaper är unika för en specifik datormodell.

Begreppet datorarkitektur inkluderar:

datorblockschema;

medel och metoder för åtkomst till element i datorblockschemat;

uppsättning och tillgänglighet av register;

organisation och metoder för adressering;

metod för presentation och format för datordata;

en uppsättning datormaskininstruktioner;

maskininstruktionsformat;

avbryta hanteringen.

De viktigaste delarna av datorhårdvara: systemenhet, tangentbord, bildskärmsenheter, diskenheter, utskriftsenheter (skrivare) och olika kommunikationsutrustning. Systemenhet består av moderkort, strömförsörjning och expansionsceller för ytterligare kort. Moderkortet innehåller en mikroprocessor, läsminne (ROM), Bagge(RAM) och samprocessor.

Register.

Inuti mikroprocessorn finns information i en grupp av 32 register (16 användare, 16 system), i en eller annan grad, tillgänglig för användning av programmeraren. Eftersom manualen ägnas åt programmering för mikroprocessorn 8088-i486 är det mest logiskt att börja detta ämne med en diskussion om mikroprocessorns interna register som är tillgängliga för användaren.

Användarregister används av programmeraren för att skriva program. Dessa register inkluderar:

åtta 32-bitars register (allmänna register) EAX/AX/AH/AL, EBX/BX/BH/BL, ECX/CX/CH/CL, EDX/DX/DLH/DL, EBP/BP, ESI/SI, EDI/DI, ESP/SP;

sex 16-bitars segmentregister: CS, DS, SS, ES, FS, GS;

status- och kontrollregister: EFLAGS/FLAGS flaggregister och EIP/IP kommandopekarregister.

Delar av ett 32-bitars register indikeras med ett snedstreck. Prefixet E (Utökad) indikerar användningen av ett 32-bitars register. För att arbeta med bytes används register med prefixen L (låg) och H(hög), till exempel AL, CH - som betecknar de låga och höga byten i registrens 16-bitarsdelar.

EAX/AX/AH/AL(Ackumulatorregister) – batteri. Används i multiplikation och division, i I/O-operationer och i vissa strängoperationer.

EBX/BX/BH/BL – basregister(basregister), används ofta vid adressering av data i minnet.

ECX/CX/CH/CL – disken(räkneregister), används som räknare för antalet repetitioner av slingan.

EDX/DX/DH/DL – dataregister(dataregister), används för att lagra mellanliggande data. I vissa lag är användningen obligatorisk.

Alla register i denna grupp tillåter åtkomst till deras "nedre" delar. Endast de nedre 16- och 8-bitarsdelarna av dessa register kan användas för självadressering. De övre 16 bitarna i dessa register är inte tillgängliga som oberoende objekt.

För att stödja strängbearbetningskommandon som tillåter sekventiell bearbetning av kedjor av element med en längd på 32, 16 eller 8 bitar, används följande:

ESI/SI (källindexregister) – index källa. Innehåller adressen till det aktuella källelementet.

EDI/DI (destinationsindexregister) – index mottagare(mottagare). Innehåller den aktuella adressen på destinationsraden.

I mikroprocessorarkitekturen stöds en datastruktur – en stack – på hård- och mjukvarunivå. Det finns särskilda instruktioner och speciella register för att arbeta med stacken. Det bör noteras att stacken fylls mot mindre adresser.

ESP/SP (stack pointer register) – Registrera pekare stack. Innehåller en pekare till toppen av stapeln i det aktuella stapelsegmentet.

EBP/BP (baspekareregister) – stackbaspekarregister. Designad för att organisera slumpmässig tillgång till data inuti stacken.

1.1.2. Segmentregister

Mjukvarumodellen för mikroprocessorer har sex segmentregister: CS, SS, DS, ES, GS, FS. Deras existens beror på den specifika organisationen och användningen av RAM av Intels mikroprocessorer. Mikroprocessorns hårdvara stöder den strukturella organisationen av programmet som består av segment. För att ange vilka segment som är tillgängliga i det här ögonblicket segmentregister är avsedda. Mikroprocessorn stöder följande segmenttyper:

Kodsegment. Innehåller programkommandon. För att komma åt detta segment, använd CS-registret (kodsegmentregister) - segmentkodregister. Den innehåller adressen till maskininstruktionssegmentet som mikroprocessorn har tillgång till.

Datasegment. Innehåller data som bearbetas av programmet. För att komma åt detta segment, använd DS-registret (datasegmentregister) - segmentdataregister, som lagrar adressen för det aktuella programmets datasegment.

Stack segment. Detta segment är ett minnesområde som kallas stacken. Mikroprocessorn organiserar stacken enligt principen - först "in", först "ut". För att komma åt stacken, använd SS-registret (stacksegmentregister) - stacksegmentregister, som innehåller adressen till stacksegmentet.

Ytterligare datasegment. Den bearbetade datan kan placeras i ytterligare tre datasegment. Som standard antas data vara i datasegmentet. När du använder ytterligare datasegment måste deras adresser anges explicit med hjälp av speciella segmentöverstyrningsprefix i kommandot. Adresser till ytterligare datasegment måste finnas i ES-, GS-, FS-registren (extensionsdatasegmentregister).

Kontroll- och statusregister

Mikroprocessorn innehåller flera register som innehåller information om tillståndet för både mikroprocessorn själv och programmet vars kommandon för närvarande laddas in i pipelinen. Detta:

EIP/IP-instruktionspekareregister;

flaggregister EFLAGS/FLAGGS.

Med hjälp av dessa register kan du få information om resultatet av kommandoexekveringen och påverka tillståndet för själva mikroprocessorn.

EIP/IP (instruktionspekareregister) – pekare lag. EIP/IP-registret är 32-bitars eller 16-bitars brett och innehåller förskjutningen av nästa instruktion som ska exekveras i förhållande till innehållet i CS-segmentregistret i det aktuella instruktionssegmentet. Detta register är inte direkt tillgängligt, men kan ändras med hjälp av hoppinstruktioner.

EFLAGS/FLAGGS (Flaggaregister) – Registrera flaggor. Bitstorlek 32/16 bitar. Individuella bitar i detta register har ett specifikt funktionssyfte och kallas flaggor. En flagga är en bit som tar värdet 1 ("flaggauppsättning") om något villkor är uppfyllt, och värdet 0 ("flaggan rensad") annars. Den låga delen av detta register är helt lik FLAGS-registret för i8086.

1.1.3 Flaggregister

Flaggregistret är 32-bitars och heter EFLAGS (fig. 1). Individuella bitar i registret har ett specifikt funktionssyfte och kallas flaggor. Var och en av dem tilldelas ett specifikt namn (ZF, CF, etc.). De lägre 16 bitarna av EFLAGS representerar 16-bitars FLAGS flaggregister som används vid exekvering av program som skrivits för mikroprocessorerna i086 och i286.

Fig.1 Flaggregister

Vissa flaggor kallas vanligtvis tillståndsflaggor; de ändras automatiskt när kommandon exekveras och registrerar vissa egenskaper för deras resultat (till exempel om det är lika med noll). Andra flaggor kallas statsflaggor; de ändras från programmet och påverkar processorns vidare beteende (till exempel blockerar de avbrott).

Skick flaggor:

CF (bärflagga) - bär flagga. Tar värdet 1 om, när man adderar heltal, en bärenhet dök upp som inte "passade" in i bitrutnätet, eller om, när man subtraherar osignerade tal, det första av dem var mindre än det andra. I skiftkommandon läggs biten som är utanför bitrutnätet in i CF. CF fångar också funktionerna i multiplikationsinstruktionen.

OF (spillflagga) - översvämningsflagga. Sätt till 1 om, när man adderar eller subtraherar tecken med heltal, resultatet är ett resultat som överskrider det tillåtna värdet i absolut värde (mantissan rann över och den "klättrade" in i teckensiffran).

ZF (nollflagga) - noll flagga. Sätt till 1 om kommandoresultatet är 0.

SF (SIgn flagga) - flagga skylt. Sätt till 1 om en operation på tecken med tecken ger ett negativt resultat.

PF (paritetsflagga) - flagga paritet. Lika med 1 om resultatet av nästa kommando innehåller ett jämnt antal binära ettor. Används vanligtvis endast för I/O-operationer.

AF (hjälpbärflagga) - extra bärflagga. Fixar funktionerna för att utföra operationer på binära decimaltal.

Statens flaggor:

DF (riktningsflagga) - riktning flagga. Ställer in riktningen för visning av linjer i linjekommandon: när DF=0, visas linjer "framåt" (från början till slut), när DF=1 - i motsatt riktning.

IOPL (input/output behörighetsnivå) – I/O-behörighetsnivå. Används i skyddat läge för mikroprocessordrift för att kontrollera åtkomst till I/O-kommandon, beroende på uppgiftens behörighet.

NT (kapslade uppgift) – uppgift häckande flagga. Används i skyddat läge för mikroprocessordrift för att registrera det faktum att en uppgift är kapslad i en annan.

Systemflagga:

IF (avbrottsflagga) - avbryta flaggan. När IF=0 slutar processorn att svara på inkommande avbrott, när IF=1 tas avbrottsblockeringen bort.

TF (fällflagga) - spåra flaggan. När TF=1, efter att ha utfört varje kommando, gör processorn ett avbrott (numrerat 1), som kan användas vid felsökning av ett program för att spåra det.

RF (resume-flagga) – återuppta flagga. Används vid bearbetning av avbrott från felsökningsregister.

VM (virtuellt 8086-läge) – virtuell 8086-flagga. 1-processorn arbetar i virtuellt 8086-läge. 0-processorn fungerar i verkligt eller skyddat läge.

AC (Alignment check) – uppriktningskontrollflagga. Designad för att tillåta inriktningskontroll vid åtkomst till minne.

Organisation av minnet.

Det fysiska minnet som mikroprocessorn har tillgång till kallas BAGGE ( eller random access memory - BAGGE). RAM är en kedja av byte som har sin egen unika adress (dess nummer), som kallas fysisk. Utbudet av fysiska adressvärden är från 0 till 4 GB. Minneshanteringsmekanismen är helt och hållet hårdvara.

Mikroprocessorns hårdvara stöder flera modeller för användning av RAM:

segmenterad modell. I denna modell är minne för program uppdelat i sammanhängande minnesområden (segment), och själva programmet kan bara komma åt de data som finns i dessa segment;

sidmodell. I det här fallet betraktas RAM som en uppsättning block med en fast storlek på 4 KB. Den huvudsakliga tillämpningen av denna modell är relaterad till organisationen virtuellt minne, vilket gör att program kan använda mer minnesutrymme än fysiskt minne. För en Pentium-mikroprocessor kan storleken på eventuellt virtuellt minne nå 4 TB.

Användningen och implementeringen av dessa modeller beror på mikroprocessorns driftläge:

Verkligt adressläge (riktigt läge). Läget liknar driften av i8086-processorn. Nödvändigt för driften av program utvecklade för tidiga processormodeller.

Skyddat läge. Skyddat läge låter dig göra flera saker informationsbearbetning, minnesskydd med hjälp av en fyra-nivås privilegiemekanism och dess personsökningsorganisation.

Virtuellt 8086-läge. I detta läge blir det möjligt att köra flera program för i8086. I detta fall kan real-mode-program fungera.

Segmentering är en adresseringsmekanism som säkerställer att det finns flera oberoende adressutrymmen. Ett segment är ett oberoende, hårdvarustödt minnesblock.

Varje program kan i allmänhet bestå av valfritt antal segment, men det har direkt tillgång till tre huvudsakliga: kod, data och stack – och från ett till tre ytterligare datasegment. Operativsystemet placerar programsegment i RAM på specifika fysiska adresser och placerar sedan värdena för dessa adresser i lämpliga register. Inom ett segment kommer programmet linjärt åt adresser i förhållande till början av segmentet, det vill säga börjar från adress 0 och slutar med en adress som är lika med segmentets storlek. Släktadress eller partiskhet, som mikroprocessorn använder för att komma åt data inom ett segment kallas effektiv.

Bildande av en fysisk adress i verkligt läge

I verkligt läge är intervallet för ändringar i den fysiska adressen från 0 till 1 MB. Den maximala segmentstorleken är 64 kB. När du kontaktar en specifik fysisk adress RAM bestäms av adressen till början av segmentet och förskjutningen inom segmentet. Segmentstartadressen hämtas från motsvarande segmentregister. I detta fall innehåller segmentregistret endast de mest signifikanta 16 bitarna av den fysiska adressen i början av segmentet. De saknade låga fyra bitarna i 20-bitars adressen erhålls genom att skifta segmentregistrets värde till vänster med 4 bitar. Skiftoperationen utförs i hårdvara. Det resulterande 20-bitarsvärdet är den verkliga fysiska adressen som motsvarar början av segmentet. Det är fysisk adress anges som ett "segment:offset"-par, där "segment" är de första 16 bitarna av startadressen för minnessegmentet som cellen tillhör, och "offset" är 16-bitarsadressen för denna cell, räknat från början av detta minnessegment (värde 16 * segment + offset ger cellens absoluta adress). Om till exempel CS-registret lagrar värdet 1234h, så definierar adressparet 1234h:507h en absolut adress lika med 16*1234h+507h =12340h+507h = 12847h. Ett sådant par skrivs som ett dubbelord och (som för siffror) i en "inverterad" form: det första ordet innehåller en offset, och det andra - ett segment, och vart och ett av dessa ord presenteras i sin tur i en "omvänd" form. Till exempel skulle paret 1234h:5678h skrivas så här:| 78 | 56| 34 | 12|.

Denna mekanism för att generera en fysisk adress gör det möjligt att göra programvaran omlokaliserbar, det vill säga oberoende av specifika laddningsadresser i RAM.

Varje maskinkommando består av två delar:

operativt - bestämma "vad man ska göra";
operand - definierar bearbetningsobjekt, "vad man ska göra med."

Kommandot för mikroprocessormaskin, skrivet i assemblerspråk, är en rad med följande syntaktiska form:

kommando/direktiv etikett operand(er) ;kommentarer

I det här fallet är det obligatoriska fältet på raden ett kommando eller direktiv.

Etiketten, kommandot/direktivet och operander (om några) är åtskilda av minst ett mellanslag eller tabbtecken.

Om ett kommando eller direktiv behöver fortsätta på nästa rad, används ett omvänt snedstreck: \.

Som standard skiljer inte assemblerspråk mellan stora och små bokstäver när du skriver kommandon eller direktiv.

Exempel på kodrader:

Räkna db 1 ;Namn, direktiv, en operand
mov eax,0 ;Kommando, två operander
cbw ; Team

Taggar

Märka i assemblerspråk kan innehålla följande symboler:

alla bokstäver i det latinska alfabetet;
siffror från 0 till 9;
specialtecken: _, @, $, ?.

En punkt kan användas som det första tecknet i en etikett, men vissa kompilatorer rekommenderar inte att du använder detta tecken. Reserverade assemblernamn (direktiv, operatorer, kommandonamn) kan inte användas som etiketter.

Det första tecknet i etiketten måste vara en bokstav eller specialtecken (men inte en siffra). Maximal längd taggar – 31 tecken. Alla etiketter som är skrivna på en rad som inte innehåller ett assemblerdirektiv måste sluta med ett kolon: .

Lag

Team talar om för översättaren vilken åtgärd mikroprocessorn ska utföra. I ett datasegment definierar ett kommando (eller direktiv) ett fält, en arbetsyta eller en konstant. I ett kodsegment specificerar ett kommando en åtgärd, som att flytta (mov) eller lägga till (lägg till).

direktiv

Montören har ett antal operatörer som låter dig styra processen för montering och listning. Dessa operatörer kallas direktiv . De agerar bara under processen att montera programmet och, till skillnad från kommandon, genererar inte maskinkod.

Operander

Operand – ett objekt på vilket ett maskinkommando eller programmeringsspråkssats exekveras.
En instruktion kan ha en eller två operander, eller inga operander alls. Antalet operander anges implicit av instruktionskoden.
Exempel:

Inga operander ret ;Retur
En operand inc ecx ;Öka ecx
Två operander lägger till eax,12 ;Lägg till 12 till eax

Etiketten, kommandot (direktivet) och operanden behöver inte starta på någon speciell position på raden. Det rekommenderas dock att skriva dem i en kolumn för att göra programmet lättare att läsa.

Operanderna kan vara

identifierare;
teckensträngar omslutna av enkla eller dubbla citattecken;
heltal i binära, oktala, decimala eller hexadecimala talsystem.

Identifierare

Identifierare – sekvenser av giltiga tecken som används för att beteckna programobjekt såsom operationskoder, variabelnamn och etikettnamn.

Regler för registrering av identifierare.

Identifieraren kan bestå av ett eller flera tecken.
Som symboler kan du använda bokstäver i det latinska alfabetet, siffror och några specialtecken: _, ?, $, @.
En identifierare kan inte börja med ett siffror.
Längden på identifieraren kan vara upp till 255 tecken.
Översättaren accepterar de första 32 tecknen i identifieraren och ignorerar resten.

Kommentarer

Kommentarer separeras från den körbara raden med ett tecken; . I det här fallet är allt som skrivs efter semikolon och fram till slutet av raden en kommentar. Att använda kommentarer i ett program förbättrar dess tydlighet, särskilt när syftet med en uppsättning kommandon är oklart. Kommentaren kan innehålla alla utskrivbara tecken, inklusive mellanslag. En kommentar kan sträcka sig över hela raden eller följa ett kommando på samma rad.

Monteringsprogrammets struktur

Ett program skrivet på assemblerspråk kan bestå av flera delar som kallas moduler . Varje modul kan ha ett eller flera data-, stack- och kodsegment definierade. Alla kompletta assemblerprogram måste innehålla en huvud- eller huvudmodul från vilken körningen börjar. En modul kan innehålla kodsegment, datasegment och stacksegment, deklarerade med hjälp av lämpliga direktiv. Innan du deklarerar segment måste du ange minnesmodellen med .MODEL-direktivet.

Ett exempel på ett "gör ingenting"-program i assemblerspråk:

686P
.MODEL FLAT, STDCALL
.DATA
.KODA
START:

RÖTA
SLUT START

Detta program innehåller endast ett mikroprocessorkommando. Detta kommando är RET. Det säkerställer att programmet avslutas korrekt. I allmänhet används detta kommando för att avsluta en procedur.
Resten av programmet gäller driften av översättaren.
.686P - Kommandon i skyddat läge Pentium 6 (Pentium II) är tillåtna. Detta direktiv väljer den uppsättning assemblerinstruktioner som stöds, som anger processormodellen. Bokstaven P som anges i slutet av direktivet informerar översättaren om att processorn arbetar i skyddat läge.
.MODEL FLAT, stdcall - platt minnesmodell. Denna minnesmodell används i operationssalen Windows-system. stdcall
.DATA är ett programsegment som innehåller data.
.CODE är ett programblock som innehåller kod.
START - etikett. I assembler spelar taggar en stor roll, vilket inte kan sägas om moderna högnivåspråk.
END START - slutet av programmet och ett meddelande till översättaren att programexekveringen ska börja med START-etiketten.
Varje modul måste innehålla ett END-direktiv för att markera slutet källkod program. Alla rader som följer END-direktivet ignoreras. Om du utelämnar END-direktivet genereras ett fel.
Etiketten som anges efter END-direktivet talar om för översättaren namnet på huvudmodulen från vilken programkörningen börjar. Om programmet innehåller en modul kan etiketten efter END-direktivet utelämnas.