Vilken typ av instruktion har assemblerspråk. Programmering: Assembly språk
Läs också
Genom syfte kan kommandon särskiljas (exempel på mnemoniska opkoder för kommandon från en PC-assembler som IBM PC finns inom parentes):
l avrättning aritmetiska operationer(ADD och ADC - tillägg och tillägg med bär, SUB och SBB - subtraktioner och subtraktioner med ett lån, MUL och IMUL - osignerade och signerade multiplikationer, DIV och IDIV - osignerade och signerade divisioner, CMP - jämförelser, etc. .);
l avrättning logiska operationer(ELLER, OCH, INTE, XOR, TEST, etc.);
l dataöverföring (MOV - skicka, XCHG - utbyte, IN - gå in i mikroprocessorn, OUT - dra tillbaka från mikroprocessorn, etc.);
l överföring av kontroll (programgrenar: JMP - ovillkorlig gren, CALL - proceduranrop, RET - retur från proceduren, J* - villkorlig gren, LOOP - loopkontroll, etc.);
l bearbetar teckensträngar (MOVS - överföringar, CMPS - jämförelser, LODS - nedladdningar, SCAS - skanningar. Dessa kommandon används vanligtvis med ett prefix (repetitionsmodifierare) REP;
l programavbrott (INT - mjukvaruavbrott, INTO - villkorliga avbrott vid spill, IRET - retur från avbrott);
l mikroprocessorkontroll (ST* och CL* - ställ in och rensa flaggor, HLT - stopp, WAIT - standby, NOP - tomgång, etc.).
MED komplett lista assembler-kommandon finns på gång.
Dataöverföringskommandon
l MOV dst, src - dataöverföring (flytta - flytta från src till dst).
Överföringar: en byte (om src och dst är i byteformat) eller ett ord (om src och dst är i ordformat) mellan register eller mellan register och minne, och skriver ett omedelbart värde till ett register eller minne.
Operanderna dst och src måste ha samma format - byte eller word.
Src kan vara av typen: r (register) - register, m (minne) - minne, i (impedans) - omedelbart värde. Dst kan vara av typen r, m. Operander kan inte användas i ett kommando: rsegm tillsammans med i; två operander av typ m och två operander av typ rsegm). Operand i kan också vara ett enkelt uttryck:
mov AX, (152 + 101B) / 15
Uttrycksutvärdering utförs endast under översättning. Flaggor ändras inte.
l PUSH src - lägga ett ord på högen (push - trycka igenom; tryck till stacken från src). Trycker in innehållet i src till toppen av stacken - vilket 16-bitars register som helst (inklusive segment) eller två minnesplatser som innehåller ett 16-bitars ord. Flaggorna ändras inte;
l POP dst - extrahera ett ord från stacken (pop - pop; räkna från stapeln i dst). Tar bort ett ord från toppen av stacken och placerar det i dst - valfritt 16-bitars register (inklusive segment) eller två minnesplatser. Flaggor ändras inte.
Kursarbete
Genom disciplin" Systemprogrammering»
Ämne nummer 4: "Lösa problem för procedurer"
Alternativ 2
STATE UNIVERSITY I ÖSTSIBIRIAN
TEKNIK OCH LEDNING
____________________________________________________________________
TEKNOLOGISK COLLEGE
TRÄNING
för terminsuppsats
| Disciplin: |
| Ämne: Problemlösning för procedurer |
| Artist(er): Glavinskaya Arina Alexandrovna |
| Chef: Sesegma Viktorovna Dambaeva |
| Kort sammanfattning av arbetet: studiet av subrutiner i Assembly language, |
| problemlösning med hjälp av subrutiner |
| 1. Teoretisk del: Grundläggande information om assemblerspråket (set |
| kommandon, etc.), Organisation av underprogram, Sätt att skicka in parametrar |
| i subrutiner |
| 2. Praktisk del: Utveckla två subrutiner, varav den ena konverterar vilken bokstav som helst till versaler (inklusive ryska bokstäver), och den andra konverterar bokstaven till gemener. |
| konverterar varje given bokstav till versaler, och den andra konverterar bokstaven till gemener. |
| konverterar en bokstav till gemener. |
| Projektets tidslinjer enligt schemat: |
| 1. Teoretisk del - 30 % senast vecka 7. |
| 2. Praktisk del - 70 % vid 11 veckor. |
| 3. Skydd - 100% inom 14 veckor. |
| Designkrav: |
| 1. Kursprojektets avräkning och förklarande anteckning ska lämnas i |
| elektroniska och papperskopior. |
| 2. Rapportens volym måste vara minst 20 maskinskrivna sidor, exklusive bilagor. |
| 3. RPP upprättas i enlighet med GOST 7.32-91 och undertecknas av chefen. |
Arbetschef __________________
Artist __________________
Utgivningsdatum " 26 " september 2017 G.
Introduktion. 2
1.1 Grundläggande information om assemblerspråket. 3
1.1.1 Kommandouppsättning. 4
1.2 Organisering av subrutiner i assemblerspråk. 4
1.3 Metoder för att skicka parametrar i subrutiner. 6
1.3.1 Att skicka parametrar genom register.. 6
1.3.2 Passa parametrar genom stacken. 7
2 PRAKTISKT AVSNITT.. 9
2.1 Redogörelse för problemet. 9
2.2 Beskrivning av problemlösningen. 9
2.3 Testa programmet.. 7
Slutsats. 8
Referenser.. 9
Introduktion
Det är välkänt att programmering i Assembly-språk är svårt. Som ni vet finns det många olika språk nu hög nivå, vilket gör att du kan spendera mycket mindre ansträngning när du skriver program. Naturligtvis uppstår frågan när en programmerare kan behöva använda Assembler när han skriver program. För närvarande finns det två områden där användningen av assemblerspråk är motiverat och ofta nödvändigt.
För det första är dessa så kallade maskinberoende systemprogram, de brukar klara sig olika enheter dator (sådana program kallas drivrutiner). Dessa systemprogram använder speciella maskininstruktioner som inte behöver användas i vanliga (eller, som de säger, applicerad) program. Dessa kommandon är omöjliga eller mycket svåra att specificera på ett högnivåspråk.
Det andra tillämpningsområdet för Assembler är relaterat till optimering av programexekvering. Mycket ofta producerar översättarprogram (kompilatorer) från högnivåspråk ett mycket ineffektivt maskinspråksprogram. Detta gäller vanligtvis program av beräkningskaraktär, där en mycket liten (cirka 3-5 %) del av programmet (huvudslingan) exekveras för det mesta. För att lösa detta problem kan så kallade flerspråkiga programmeringssystem användas, som låter dig skriva delar av programmet på olika språk. Vanligtvis är huvuddelen av programmet skrivet på ett högnivå programmeringsspråk (Fortran, Pascal, C, etc.), och de tidskritiska delarna av programmet skrivs i Assembler. I det här fallet kan hastigheten på hela programmet öka avsevärt. Ofta detta det enda sättet att tvinga programmet att ge ett resultat inom acceptabel tid.
Detta terminspapperär att få praktiska färdigheter i programmering i assemblerspråk.
Arbetsuppgifter:
1. Att studera den grundläggande informationen om Assembler-språket (strukturen och komponenterna i programmet i Assembler, formatet på kommandon, organisationen av subrutiner, etc.);
2. Att studera typerna av bitoperationer, formatet och logiken för assemblerlogikkommandona;
3. Lös ett individuellt problem för användningen av subrutiner i Assembler;
4.. Formulera en slutsats om det utförda arbetet.
1 TEORETISKT AVSNITT
Grunderna i monteringsspråket
Assembler är ett programmeringsspråk på låg nivå som är ett format för att skriva maskininstruktioner som är bekvämt för mänsklig perception.
Assembly språkkommandon motsvarar ett till ett processorkommandon och representerar i själva verket en bekväm symbolisk form av notation (mnemonisk kod) av kommandon och deras argument. Assembly language ger också grundläggande programmeringsabstraktioner: länkar samman delar av ett program och data genom etiketter med symboliska namn och direktiv.
Monteringsdirektiv tillåter dig att inkludera datablock (beskrivna explicit eller lästa från en fil) i programmet; upprepa ett visst fragment ett visst antal gånger; kompilera fragmentet enligt tillståndet; ställ in fragmentexekveringsadressen, ändra etikettvärden under kompilering; använda makrodefinitioner med parametrar osv.
Fördelar och nackdelar
Minsta mängd redundant kod (användningen av färre kommandon och minnesåtkomster). Som en konsekvens - högre hastighet och mindre programstorlek;
stora mängder kod, ett stort antal ytterligare små uppgifter;
Dålig läsbarhet av koden, svårigheter med support (felsökning, lägga till funktioner);
· Svårigheten att implementera programmeringsparadigm och andra lite komplexa konventioner, komplexiteten i gemensam utveckling;
Färre tillgängliga bibliotek, deras låga kompatibilitet;
· direkt tillgång till hårdvara: ingångs-utgångsportar, speciella processorregister;
maximal "passning" för den önskade plattformen (användning av speciella instruktioner, tekniska funktioner"körtel");
· icke-portabilitet till andra plattformar (förutom för binärt kompatibla sådana).
Förutom instruktioner kan programmet innehålla direktiv: kommandon som inte översätts direkt till maskininstruktioner, utan styr kompilatorns funktion. Deras uppsättning och syntax varierar avsevärt och beror inte på hårdvaruplattformen, utan på kompilatorn som används (som ger upphov till dialekter av språk inom samma familj av arkitekturer). Som en uppsättning direktiv kan vi särskilja:
Definition av data (konstanter och variabler);
hantering av programmets organisation i minnet och parametrarna för utdatafilen;
ställa in kompilatorläget;
Alla typer av abstraktioner (d.v.s. element av högnivåspråk) - från utformningen av procedurer och funktioner (för att förenkla implementeringen av det procedurmässiga programmeringsparadigmet) till villkorliga strukturer och loopar (för det strukturella programmeringsparadigmet);
makron.
Kommandouppsättning
Typiska instruktioner för monteringsspråk är:
Dataöverföringskommandon (mov, etc.)
· Aritmetiska kommandon(lägg till, sub, imul, etc.)
Logiska och bitvisa operationer (eller, och, xor, shr, etc.)
Kommandon för att hantera programexekveringen (jmp, loop, ret, etc.)
Avbryta anropskommandon (ibland kallade kontrollkommandon): int
I/O-kommandon till portar (in, ut)
Mikrokontroller och mikrodatorer kännetecknas också av kommandon som utför kontroller och övergångar efter tillstånd, till exempel:
· jne - hoppa om inte lika;
· jge - hoppa om större än eller lika med .
För att maskinen ska kunna utföra mänskliga kommandon på hårdvarunivå är det nödvändigt att ställa in viss sekvens handlingar på språket nollor och ettor. Assembler kommer att bli assistent i denna fråga. Detta är ett verktyg som fungerar med översättning av kommandon till maskinspråk. Att skriva ett program är dock en mycket tidskrävande och komplex process. Detta språk är inte avsett att skapa ljus och enkla åtgärder. På det här ögonblicket alla programmeringsspråk du använder (Assembler fungerar utmärkt) låter dig skriva speciella effektiva uppgifter som i hög grad påverkar hur hårdvaran fungerar. Huvudsyftet är att skapa mikroinstruktioner och små koder. Detta språk ger fler funktioner än till exempel Pascal eller C.
Kort beskrivning av assemblerspråk
Alla programmeringsspråk är indelade i nivåer: låg och hög. Vilket som helst av de syntaktiska systemen i Assemblers "familj" är annorlunda genom att det samtidigt kombinerar några av fördelarna med de vanligaste och modernaste språken. De är också relaterade till andra genom att du kan använda datorsystemet fullt ut.
En utmärkande egenskap hos kompilatorn är dess användarvänlighet. I detta skiljer den sig från de som bara fungerar med höga nivåer. Om något sådant programmeringsspråk beaktas, fungerar Assembler dubbelt så snabbt och bättre. För att skriva ett lättviktsprogram i det kommer det inte att ta för mycket tid.
Kort om språkets struktur
Om vi pratar i allmänhet om arbetet och strukturen för språkets funktion, kan vi med säkerhet säga att dess kommandon är helt förenliga med processorns kommandon. Det vill säga, assemblern använder mnemoniska koder som är mest bekväma för en person att skriva.
Till skillnad från andra programmeringsspråk använder Assembler specifika etiketter istället för adresser för att skriva minnesceller. De översätts till de så kallade direktiven med kodexekveringsprocessen. Dessa är relativa adresser som inte påverkar driften av processorn (de är inte översatta till maskinspråk), men som är nödvändiga för igenkänning av själva programmeringsmiljön.
Varje processorlinje har sin egen. I denna situation kommer alla processer att vara korrekta, inklusive den översatta.
Assembly språk har flera syntaxer, som kommer att diskuteras i artikeln.
Språkproffs
Den viktigaste och bekvämaste anpassningen av assemblerspråket kommer att vara att det kan användas för att skriva vilket program som helst för processorn, vilket kommer att vara mycket kompakt. Om koden är enorm omdirigeras vissa processer till Bagge. Samtidigt presterar de alla ganska snabbt och utan misslyckanden, såvida de inte, naturligtvis, kontrolleras av en kvalificerad programmerare.
Drivrutiner, operativsystem, BIOS, kompilatorer, tolkar etc. är alla assemblerspråksprogram.
När du använder en disassembler som översätter från maskin till maskin kan du enkelt förstå hur den eller den systemuppgiften fungerar, även om det inte finns några förklaringar till det. Detta är dock bara möjligt om programmen är lätta. Tyvärr är det ganska svårt att förstå icke-triviala koder.
Nackdelar med språket
Tyvärr är det svårt för nybörjare (och ofta proffs) att förstå språket. Montör kräver detaljerad beskrivningönskat kommando. På grund av att maskininstruktioner måste användas ökar sannolikheten felaktiga handlingar och komplexiteten i genomförandet.
För att skriva ens det mesta ett enkelt program, programmeraren måste vara kvalificerad och hans kunskapsnivå är tillräckligt hög. Den genomsnittlige specialisten skriver tyvärr ofta dåliga koder.
Om plattformen som programmet skapas för uppdateras måste alla kommandon skrivas om manuellt - detta krävs av själva språket. Montören stöder inte funktionen för automatisk reglering av processernas hälsa och byte av några element.
Språkkommandon
Som nämnts ovan har varje processor sin egen uppsättning instruktioner. De enklaste elementen som känns igen av någon typ är följande koder:
Använder direktiv
Programmering av mikrokontroller i språket (Assembler tillåter detta och fungerar utmärkt) på den lägsta nivån slutar i de flesta fall framgångsrikt. Det är bäst att använda processorer med en begränsad resurs. För 32-bitars teknik givet språk passar jättebra. Du kan ofta se direktiv i koder. Vad är detta? Och vad används den till?
Till att börja med är det nödvändigt att betona att direktiv inte översätts till maskinspråk. De styr hur kompilatorn fungerar. Till skillnad från kommandon skiljer sig inte dessa parametrar, även om de har olika funktioner, på grund av olika processorer, men på bekostnad av en annan översättare. Huvuddirektiven inkluderar följande:
namnets ursprung
Vad heter språket - "Assembler"? Vi pratar om en översättare och en kompilator, som krypterar data. Från engelska betyder Assembler inget annat än en assembler. Programmet kompilerades inte för hand, utan en automatisk struktur användes. Dessutom har användare och specialister för närvarande redan raderat skillnaden mellan termerna. Ofta kallas assembler programmeringsspråk, även om det bara är ett verktyg.
På grund av det allmänt accepterade samlingsnamnet har vissa människor det felaktiga antagandet att det finns ett enda lågnivåspråk (eller standardnormer för det). Så att programmeraren förstår vilken struktur i fråga, är det nödvändigt att ange för vilken plattform detta eller det assemblerspråket används.
makroverktyg
Assembler-språk, som är relativt nya, har makrofunktioner. De gör det lättare att både skriva och köra ett program. På grund av deras närvaro exekverar översättaren den skrivna koden många gånger snabbare. När du skapar ett villkorligt val kan du skriva ett stort block av kommandon, men det är lättare att använda makron. De gör att du snabbt kan växla mellan åtgärder, om ett villkor uppfylls eller inte uppfylls.
När du använder makrospråkdirektiv tar programmeraren emot Assembler-makron. Ibland kan den användas i stor utsträckning, och ibland reduceras dess funktionalitet till ett enda kommando. Deras närvaro i koden gör det lättare att arbeta med den, gör den mer begriplig och visuell. Men du bör fortfarande vara försiktig - i vissa fall förvärrar makron tvärtom situationen.
Introduktion.
Språket som originalprogrammet är skrivet på kallas inmatning språk och språket till vilket det översätts för exekvering av processorn - helgen språk. Processen att konvertera ett inmatningsspråk till ett 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översättningar: sammanställning och tolkning.
På kompilering källprogrammet översätts först helt till ett motsvarande program på målspråket, kallat objekt program och sedan körs. Denna process utförs med hjälp av en speciell program, kallad kompilator. En kompilator för vilken inmatningsspråket är en symbolisk representation av maskinspråket (utdata) för binära koder kallas assemblerare.
På tolkningar varje rad med källprogramtext tolkas (tolkas) och kommandot som anges i den exekveras omedelbart. Implementeringen av denna metod ligger hos tolkprogram. Tolkning tar lång tid. För att öka dess effektivitet, istället för att bearbeta varje rad, konverterar tolken preliminärt alla kommando 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 (
) mnemonic 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 de symboliska namnen som assemblern översätter till binära koder;
● varje påstående motsvarar ett maskinkommando(kod), det vill säga det finns en en-till-en-överensstämmelse mellan maskininstruktioner 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 en flaggregisterbit och ett högnivåspråk (till exempel,
) har inte denna funktion. Observera att språk för systemprogrammering (till exempel C) ofta har en mellanposition. När det gäller tillgänglighet ligger de närmare assemblerspråk, men de 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 assemblerprogram. Trots detta har assemblerspråk blivit bred användning på grund av följande omständigheter:
● Ett program skrivet på assemblerspråk har en betydande mindre storlekar och är mycket snabbare än ett program skrivet på ett högnivåspråk. För vissa applikationer spelar dessa indikatorer en primär roll, till exempel många systemprogram (inklusive kompilatorer), program i kreditkort, mobiltelefoner, enhetsdrivrutiner, etc.;
● vissa procedurer kräver full tillgång till hårdvara, vilket vanligtvis inte är möjligt på ett högnivåspråk. Detta ärende inkluderar avbrott och avbrottshanterare i operativsystem, samt enhetskontroller i inbyggda system som fungerar i realtid.
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. En etikett är ett symboliskt namn, eller identifierare, adresser minne. Det är nödvändigt för att kunna:
● gör en villkorlig eller ovillkorlig övergång till kommandot;
● få tillgång till platsen där data lagras.
Sådana uttalanden är märkta. För att beteckna ett namn används (versaler) bokstäver i det engelska alfabetet och siffror. Namnet måste börja med en bokstav och sluta med ett kolon. 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 gör det omöjligt att skilja mellan en etikett och en opkod om de är på separata rader.
I vissa versioner av assemblerspråk placeras kolon endast efter instruktionsetiketter, inte efter dataetiketter, och etikettlängden kan begränsas till 6 eller 8 tecken.
Etikettfältet bör inte innehålla samma namn, eftersom etiketten är associerad med adresserna för kommandon. Om det inte finns något behov av att anropa ett kommando eller data från minnet under programexekveringen, förblir etikettfältet tomt.
Fält för transaktionskod.
Detta fält innehåller kommandot mnemonic eller pseudo-kommando (se nedan). Kommandot mnemonisk kod väljs av språkdesignerna. På assemblerspråk
mnemonik vald för att ladda register från minnet
), och för att lagra innehållet i registret i minnet - mnemoniken
). På assemblerspråk
du kan använda samma namn för båda operationerna
Om valet av mnemoniska namn kan vara godtyckligt, beror behovet av att använda två maskininstruktioner på processorarkitekturen
Registermnemonics beror också på assemblerversionen (tabell 5.2.1). 
Operandfält.
Här ligger ytterligare information krävs för att utföra operationen. I fältet operander för hoppinstruktioner anges adressen där du vill hoppa, samt adresser och register som är operander för maskininstruktionen. Som ett exempel, här är operanderna 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 de latinska bokstäverna: B,
Följaktligen, binära, oktala, hexadecimala, decimala talsystem (
kanske inte spelas in). Om den första siffran i det hexadecimala talet är A, B, C,
Sedan läggs en obetydlig 0 (noll) till framför;
● koder för mikroprocessorns interna register 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 10V - registeradress
i binärt system);
● identifierare,
för registrerade flygplanspar,
De första bokstäverna B
H; för ett par ackumulator- och funktionsregister -
; för programräknaren -
; för stackpekare -
● etiketter som indikerar adresser till operander eller nästa instruktioner i villkorligt
(när 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 byggda genom att länka data som diskuterats ovan med hjälp av aritmetiska och logiska operatorer. Observera att hur datautrymme reserveras beror på språkversionen. Assembly språkutvecklare för
Definiera ordet), och introducerade senare ett alternativ.
som från allra första början var på språket för processorer
I språkversion
Begagnade
definiera en konstant).
Processorer bearbetar operander av olika längd. För att definiera det har assemblerutvecklare tagit 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 opcode: suffix
För typ
; suffix ".B" för typ
för operander av olika längd används olika koder operationer, till exempel för att ladda en byte, ett halvord (
) och ord i 64-bitars register använder opkoder
respektive.
Kommentarsfält.
Det här fältet ger förklaringar om programmets åtgärder. Kommentarer påverkar inte driften av programmet och är avsedda för en person. 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 ett tecken 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 rad reserverad för en kommentar föregås av ett starttecken.
Pseudo-kommandon (direktiv).
I assemblerspråk kan två huvudtyper av kommandon särskiljas:
● grundläggande instruktioner som motsvarar processorns maskinkod. Dessa kommandon utför all bearbetning som tillhandahålls av programmet;
● pseudo-kommandon eller direktiv, utformad för att tjäna processen att översätta programmet till språket för kodkombinationer. Som ett exempel, i Tabell. 5.2.2 visar några pseudo-kommandon från as-assembler
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 önskad sekvens av kommandon när den inträffar. Detta tillvägagångssätt leder till en ökning av programmets volym;
● ordna denna sekvens i en procedur (subrutin) och anropa den vid behov. En sådan utgång har sina nackdelar: varje gång måste du utföra en speciell proceduranropsinstruktion och en returinstruktion, som med en kort och ofta använd sekvens avsevärt kan minska programmets hastighet.
Den enklaste och effektiv metod upprepad upprepning av en kedja av kommandon är att använda makro, som kan ses som ett pseudokommando utformat för att återöversätta en grupp av kommandon som ofta påträffas i ett program.
Ett makro, eller makroinstruktion, kännetecknas av tre aspekter: makrodefinition, makroinversion och makroexpansion.
makro definition
Detta är en beteckning för en upprepad sekvens av programkommandon, som används för referenser i programtexten.
Ett makro har följande struktur:
Lista över uttryck; makro definition
Det finns tre delar i makrodefinitionsstrukturen ovan:
● sidhuvud
makro som innehåller namnet
Pseudo-kommando
och en uppsättning parametrar;
● prickade kropp makro;
● team
gradering
makrodefinitioner.
En makroparameteruppsättning innehåller en lista över alla parametrar som anges i operandfältet för den valda instruktionsgruppen. Om dessa parametrar anges tidigare i programmet kan de utelämnas i makrodefinitionshuvudet.
För återmontering av den valda gruppen av instruktioner används ett anrop som består av namnet
makro och parameterlista med andra värden.
När assemblern stöter på en makrodefinition under kompileringen, lagrar den den i makrodefinitionstabellen. Med efterföljande uppträ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 dess ersättning av makrots kropp - makroexpansion.
Om programmet representeras som en sekvens av tecken (bokstäver, siffror, mellanslag, skiljetecken och vagn går tillbaka för att hoppa till ny linje), så består makroexpansion i att ersätta vissa kedjor från denna sekvens med andra kedjor.
Makroexpansion sker under monteringsprocessen, inte under programkörning. Sätt att manipulera teckensträngar tilldelas makroverktyg.
Monteringsprocessen genomförs i två omgångar:
● Vid första passet behålls alla makrodefinitioner och makroanrop utökas. I detta fall läses källprogrammet och konverteras till ett program där alla makrodefinitioner tas bort, och varje makroanrop ersätts av en makrokropp;
● Det andra passet bearbetar det mottagna programmet utan makron.
Makron med parametrar.
Att arbeta med upprepade sekvenser av kommandon, vars parametrar kan ta olika betydelser, finns 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 makrots brödtext med motsvarande faktiska parameter.
använda makron med parametrar.
Program 1 visar 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 ett makroanrop
program 2 är märkt: P,
Den första faktiska parametern,
Den 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.
Tänk på några avancerade funktioner i språket
Om ett makro som innehåller en villkorlig greninstruktion och en etikett att hoppa till anropas två eller flera gånger, kommer etiketten att dupliceras (etikettdupliceringsproblem), vilket kommer att orsaka ett fel. Därför tilldelas varje anrop (av programmeraren) en separat etikett som en parameter. På språket
etiketten deklareras lokal (
) och tack vare de avancerade funktionerna 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 när den kombineras med villkorad programlänkning. Överväga
IF WORDSIZE GT 16 M2 MAKRO
Makro M2 kan definieras i båda delarna av uttalandet
Men definitionen beror på om programmet monteras på en 16-bitars eller 32-bitars processor. 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 makron i assembler.
När du använder makron måste assemblern kunna utföra två funktioner: spara makrodefinitioner Och expandera makroanrop.
Sparar 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 separat bord för makronamn, andra - en vanlig tabell där det, tillsammans med namnen på makron, finns alla maskinkommandon och direktiv.
När du stöter på ett makro under montering skapat:
● nytt bordselement med namnet på makrot, antalet parametrar och en pekare till en annan makrodefinitionstabell där makrokroppen 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 slingkroppen ä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.
Makro samtalstillägg.
Närhelst en makrodefinition påträffas under monteringen lagras den i makrotabellen. När ett makro anropas avbryter assemblern läsningen av indata från inmatningsenheten tillfälligt och börjar läsa den sparade makrokroppen. De formella parametrarna som extraherats från makrokroppen ersätts av de faktiska parametrarna och tillhandahålls av anropet. Ett och-tecken & framför parametrarna gör att assemblern kan känna igen dem.
Även om det finns många versioner av assembler, har monteringsprocesser gemensamma egenskaper och är lika på många sätt. Arbetet av en två-pass assembler betraktas nedan.
Två pass assembler.
Programmet består av ett antal påståenden. Därför verkar det som att följande sekvens av åtgärder kan användas under montering:
● översätta det till maskinspråk;
● överföra den mottagna maskinkoden till en fil, och motsvarande del av förteckningen - till en annan fil;
● upprepa procedurerna ovan tills hela programmet har sänts.
Detta tillvägagångssätt är dock inte effektivt. Ett exempel är det så kallade problemet ledande länk. Om den första satsen är ett hopp till P-satsen i slutet av programmet, kan assembleraren inte översätta den. Han måste först bestämma adressen till operatören P, och för detta är det nödvändigt att läsa hela programmet. Varje fullständig läsning av originalprogrammet kallas textavsnitt. Låt oss visa hur vi kan lösa det framåtriktade referensproblemet med två pass:
● vid första passet 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 den andra passagen genom det ursprungliga programmet kräver ytterligare I/O-tid;
● vid första passet, konvertera programmera till en mellanform och spara den i en tabell, och det andra passet utförs inte enligt det ursprungliga programmet, utan enligt tabellen. Denna monteringsmetod sparar tid, eftersom inga I/O-operationer utförs vid det andra passet.
Första passet.
Syftet med det första passet- bygga ett symbolbord. Som nämnts ovan är ett annat mål med det första passet att spara alla makrodefinitioner och utöka anropen när de visas. Därför sker både teckendefinition och makroexpansion i samma pass. Symbolen kan vara antingen märka, eller menande, som tilldelas ett specifikt namn med -you-direktivet:
;Värde - buffertstorlek 
Genom att ge betydelse åt de symboliska namnen i instruktionsetikettfältet, ställer assemblern i huvudsak de adresser som varje instruktion kommer att ha under programexekveringen. För att göra detta sparar 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 ett exempel, i Tabell. 5.2.3 visar ett fragment av programmet som anger längden på kommandon och räknarvärden. Tabeller genereras under det första passet symbolnamn, direktiv Och operationskoder, och vid behov bokstavlig tabell. En literal är en konstant som assembleraren automatiskt reserverar minne för. Det noterar vi genast moderna processorer innehåller instruktioner med omedelbara adresser, så deras assemblers stöder inte bokstavliga ord. 
Symbol tabell
innehåller ett element för varje namn (tabell 5.2.4). Varje element i symboltabellen 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;
● minnesomappningsbitar (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.
Tabell över direktiv.
Den här tabellen listar alla direktiv, eller pseudo-kommandon, som inträffar när ett program sätts samman.
Driftkodtabell.
För varje op-kod har tabellen separata kolumner: op-kod-beteckning, operand 1, operand 2, hexadecimalt värde för op-koden, instruktionslängd och instruktionstyp (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.
Syftet med det andra passet- skapa ett objektprogram och skriva ut, om nödvändigt, ett monteringsprotokoll; mata ut information som behövs av länken för att 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 efter varandra. Den ursprungliga operatorn och härledd från den i hexadecimalt system ledig dag objekt koden kan skrivas ut eller buffras för senare utskrift. Efter återställning av kommandoadressräknaren anropas nästa sats.
Det ursprungliga programmet kan innehålla fel, till exempel:
● den givna symbolen är inte definierad eller definierad mer än en gång;
● Op-koden representeras av ett ogiltigt namn (på grund av ett stavfel), inte försett med tillräckligt många 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 en sats med ett fel hittas, visar assemblern ett felmeddelande på skärmen och försöker fortsätta monteringsprocessen.
Artiklar tillägnade assemblerspråket.
Allmän information om assemblerspråk
Det symboliska assemblerspråket gör det möjligt att i stort sett eliminera bristerna med maskinspråksprogrammering.
Dess främsta fördel är att i assemblerspråk representeras alla programelement i symbolisk form. Omvandlingen av symboliska kommandonamn till deras binära koder är ansvaret för specialprogram- assembler, som befriar programmeraren från mödosamt arbete och eliminerar de oundvikliga felen.
Symboliska namn som introduceras vid programmering i assemblerspråk återspeglar som regel programmets semantik och förkortningen av kommandon - deras huvudfunktion. Till exempel: PARAM - parameter, TABELL - tabell, MASK - mask, ADD - addition, SUB - subtraktion, etc. n. Sådana namn kommer lätt ihåg av programmeraren.
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å mikrodatorer eller datorer med en uppsättning kringutrustning(alfanumeriskt tangentbord, teckendisplay, diskettenhet och skrivare), 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, det vill säga beroende på maskinspråket och strukturen för motsvarande mikroprocessor, eftersom de tilldelar ett specifikt symboliskt namn till varje mikroprocessorinstruktion.
Monteringsspråk ger en betydande ökning av produktiviteten hos programmerare 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 skickliga programmerare att skriva program som körs på kortare tid och tar upp mindre minne än program skrivna på ett högnivåspråk.
I detta avseende är nästan alla I/O-enhetskontrollprogram (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:
mnemonisk (symboliskt namn) för varje kommando i mikroprocessorns maskinspråk;
standardformat för rader i ett program som beskrivs i assembler;
format för att specificera olika sätt adresserings- och kommandoalternativ;
format för att specificera teckenkonstanter och konstanter av heltalstyp i olika talsystem;
pseudo-kommandon som styr processen för montering (översättning) av programmet.
På assemblerspråk skrivs programmet rad för rad, det vill säga en rad tilldelas för varje instruktion.
För mikrodatorer byggda på basis av de vanligaste typerna av mikroprocessorer kan det finnas flera varianter av assemblerspråk, dock har man oftast en praktisk fördelning - detta är det så kallade standard assemblerspråket
Programmering på maskininstruktionsnivå är den lägsta nivån på vilken programmering är möjlig. 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 maskininstruktion består av två delar:
drift - bestämma "vad man ska göra";
· operand - definierar bearbetningsobjekt, "vad man ska göra med".
Maskininstruktionen för mikroprocessorn, skriven i assemblerspråk, är en enda rad med följande syntaktiska form:
etikett kommando/direktiv operand(er) ;kommentarer
Vart i obligatoriskt fält in line är 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 bakstrecket: \.
Som standard skiljer inte assemblerspråk mellan stora och små bokstäver i kommandon eller direktiv.
Direkt adressering: Den effektiva adressen bestäms direkt av maskininstruktionsoffsetfältet, som kan vara 8, 16 eller 32 bitar stort.
mov eax, summa ; eax = summa
Samlaren ersätter summan med motsvarande adress lagrad i datasegmentet (som standard adresserad av register ds) och placerar värdet som lagrats vid adresssumma i register eax.
indirekt adressering har i sin tur följande typer:
Indirekt grundläggande (register) adressering;
Indirekt grundläggande (register) adressering med offset;
· indirekt indexadressering;
· indirekt basindexadressering.
Indirekt grundläggande (register) adressering. Med denna adressering kan den effektiva adressen för operanden finnas 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 ett stacksegment). Syntaktisk i en instruktion uttrycks detta adresseringsläge genom att omge registernamnet inom hakparenteser.
mov eax, ; eax = *esi; *esi-värde vid adress esi