Assembleri keel: madala taseme programmeerimiskeel ja masinkood

Kui arvutiteadlased esimest korda programmeeritavaid masinaid ehitasid, programmeerisid nad neid otse masinakoodiga, mis on numbrite rida, mis andis arvutile juhised, mida teha. Masinakeele kirjutamine oli väga raske ja võttis kaua aega, nii et lõpuks tehti assembleri keel. Assamblee keelt on inimesel lihtsam lugeda ja seda saab kirjutada kiiremini, kuid seda on inimesel siiski palju raskem kasutada kui kõrgetasemelist programmeerimiskeelt, mis püüab jäljendada inimkeelt.

Programmeerimine masinkoodis

Masinakoodis programmeerimiseks peab programmeerija teadma, kuidas iga käsk binaarselt (või heksadekaalis) välja näeb. Kuigi arvutil on lihtne kiiresti aru saada, mida masinkood tähendab, on see programmeerijale raske. Igal käsul võib olla mitu vormi, mis kõik näevad inimeste jaoks lihtsalt välja nagu hunnik numbreid. Iga viga, mille keegi teeb masinkoodi kirjutamisel, märkab alles siis, kui arvuti teeb valesti. Vea väljaselgitamine on raske, sest enamik inimesi ei oska seda vaadates öelda, mida masinkood tähendab. Näide sellest, kuidas masinkood välja näeb:

05 2A 00

See heksadekvaliteetne masinakood annab x86-arvuti protsessorile käsu lisada akumulaatorisse 42. Seda on inimesel väga raske lugeda ja mõista, isegi kui ta tunneb masinakoodi.

Assembleri keele kasutamine selle asemel

Assembleri keeles saab iga käsu kirjutada lühikese sõnana, mida nimetatakse mnemoonikaks, millele järgnevad muud asjad, näiteks numbrid või muud lühikesed sõnad. Mnemoonikat kasutatakse selleks, et programmeerija ei peaks meeles pidama täpseid numbreid masinakoodis, mida on vaja, et käskida arvutil midagi teha. Assembleri keele mnemoonika näited on näiteks add, mis lisab andmeid, ja mov, mis liigutab andmeid ühest kohast teise. Kuna "mnemoonika" on ebatavaline sõna, kasutatakse selle asemel mõnikord, sageli valesti, väljendit "käsu tüüp" või lihtsalt "käsk". Esimese sõna järel olevad sõnad ja numbrid annavad rohkem teavet selle kohta, mida teha. Näiteks võivad liitmise järel olevad asjad öelda, milliseid kahte asja kokku liita, ja liikumisele järgnevad asjad ütlevad, mida liigutada ja kuhu panna.

Näiteks eelmises punktis esitatud masinakoodi (05 2A 00) saab assembleris kirjutada järgmiselt:

Assembleri keel võimaldab programmeerijatel ka lihtsamalt kirjutada tegelikke andmeid, mida programm kasutab. Enamikul assembleri keeltel on toetus numbrite ja teksti lihtsaks koostamiseks. Masinakoodis tuleks iga eri tüüpi arv, nagu positiivne, negatiivne või kümnendarv, käsitsi teisendada binaarseks ja tekst tuleks defineerida üks täht korraga, nagu numbrid.

Assembleri keel pakub nn masinkoodi abstraktsiooni. Assembleri kasutamisel ei pea programmeerija teadma, mida numbrid arvutile tähendavad, selle asemel arvutab seda assembler. Assembleri keel võimaldab programmeerijal tegelikult ikkagi kasutada kõiki protsessori funktsioone, mida ta saaks kasutada masinkoodiga. Selles mõttes on assembleri keelel väga hea ja haruldane omadus: ta suudab samu asju väljendada kui see, mida ta abstraheerib (masinkood), olles samas palju lihtsamini kasutatav. Seetõttu ei kasutata masinkoodi peaaegu kunagi programmeerimiskeelena.

Demonteerimine ja vigade kõrvaldamine

Kui programmid on valmis, on need juba muundatud masinkoodiks, nii et protsessor saab neid tegelikult käivitada. Mõnikord aga, kui programmis on mingi viga (viga), tahavad programmeerijad teada, mida iga masinkoodi osa teeb. Disassemblerid on programmid, mis aitavad programmeerijatel seda teha, muutes programmi masinkoodi tagasi assemblerikeeleks, mis on palju lihtsamini arusaadav. Disassemblerid, mis muudavad masinkoodi assemblerikeeleks, teevad vastupidist assembleritele, mis muudavad assemblerikeele masinkoodiks.

Assembleri programmi toimimise mõistmiseks on vaja arusaamist sellest, kuidas arvutid on korraldatud, kuidas nad näiliselt väga madalal tasemel töötavad. Kõige lihtsamal tasemel on arvutitel kolm peamist osa:

1. põhimälu ehk RAM, milles hoitakse andmeid ja käske,
2. protsessor, mis töötleb andmeid, täites käske, ja
3. sisend ja väljund (mõnikord lühendatult I/O), mis võimaldavad arvutil suhelda välismaailmaga ja salvestada andmeid väljaspool põhimälu, et neid hiljem tagasi saada.

Põhimälu

Enamikus arvutites on mälu jagatud baitideks. Iga bait sisaldab 8 bitti. Igal mälu baidil on ka aadress, mis on number, mis ütleb, kus see bait mälus asub. Esimese baidi aadress mälus on 0, järgmise baidi aadress on 1 jne. Mälu jagamine baitideks muudab selle baitide kaupa adresseeritavaks, sest iga bait saab unikaalse aadressi. Baitmälu aadressid ei saa viidata baitide üksikule bitile. Bait on väikseim adresseeritav mäluosa.

Kuigi aadress viitab konkreetsele baidile mälus, võimaldavad protsessorid kasutada mitu baiti järjestikku. Kõige sagedamini kasutatakse seda funktsiooni 2 või 4 baiti järjest, et kujutada numbrit, tavaliselt täisarvu. Mõnikord kasutatakse täisarvude esitamiseks ka üksikuid baite, kuid kuna need on ainult 8 bitti pikad, saavad need sisaldada ainult 2 ⁸või 256 erinevat võimalikku väärtust. Kasutades 2 või 4 baiti reas, suureneb erinevate võimalike väärtuste arv vastavalt 2 ¹⁶, 65536 või 2 ³², 4294967296.

Kui programm kasutab baiti või mitut baiti järjestikku, et kujutada midagi, näiteks tähte, numbreid või midagi muud, nimetatakse neid baite objektiks, sest nad kõik on osa ühest ja samast asjast. Kuigi kõik objektid on salvestatud ühesugustes mälubaitides, käsitletakse neid nii, nagu oleks neil "tüüp", mis ütleb, kuidas neid baite tuleb mõista: kas täisarvuna või märgina või mingi muu tüübina (näiteks mitte täisarvu väärtus). Masinakoodi võib mõelda ka tüübina, mida tõlgendatakse käskudena. Tüübi mõiste on väga-väga oluline, sest see määrab, milliseid asju saab ja ei saa objektiga teha ja kuidas objekti baite tõlgendada. Näiteks ei ole lubatud negatiivset arvu salvestada positiivse arvu objekti ja ei ole lubatud murdarvu salvestada täisarvu objekti.

Mitme baidiga objektile osutav (on selle aadress) aadress on selle objekti esimese baidi aadress - kõige madalama aadressiga baidi aadress. Kõrvalmärkusena olgu öeldud, et aadressi järgi ei saa öelda, mis tüüpi objekt on - või isegi selle suurust -. Tegelikult ei saa te isegi seda, mis tüüpi objekt on, seda vaadates öelda. Assembleri programm peab jälgima, millistel mäluaadressidel millised objektid asuvad ja kui suured need objektid on. Programm, mis seda teeb, on tüübikindel, sest ta teeb objektidega ainult selliseid asju, mis on nende tüübi järgi turvalised. Programm, mis seda ei tee, tõenäoliselt ei tööta korralikult. Pange tähele, et enamik programme ei salvesta tegelikult selgesõnaliselt, mis on objekti tüüp, nad lihtsalt pääsevad objektidele järjepidevalt ligi - sama objekti käsitletakse alati sama tüübina.

Protsessor

Protsessor töötab (täidab) käske, mis on salvestatud masinakoodina põhimällu. Lisaks sellele, et enamikul protsessoritel on võimalik kasutada mälu salvestamiseks, on neil ka mõned väikesed, kiired ja fikseeritud suurusega ruumid, kus hoitakse objekte, millega parajasti töötatakse. Neid ruume nimetatakse registriteks. Protsessorid täidavad tavaliselt kolme tüüpi käske, kuigi mõned käsud võivad olla nende tüüpide kombinatsioon. Allpool on toodud mõned näited igast tüübist x86 assembleri keeles.

Käsklused, mis loevad või kirjutavad mälu

Järgmine x86 assembleri käsk loeb (laeb) 2baidise objekti aadressilt 4096 (0x1000 heksadekaalis) 16-bitisse registrisse nimega 'ax':

Selles koostekeeles tähendavad numbri (või registri nime) ümber olevad nurksulgud seda, et numbrit tuleb kasutada aadressina andmete jaoks, mida tuleks kasutada. Aadressi kasutamist andmetele osutamiseks nimetatakse indirektsiooniks. Järgmises näites, ilma nurksulgudeta, laetakse teise registrisse, bx, tegelikult väärtus 20.

Kuna indirektsiooni ei kasutatud, siis tegelik väärtus ise pandi registrisse.

Kui operandid (asjad, mis tulevad pärast mnemonüümi), esinevad vastupidises järjekorras, siis käsk, mis laeb midagi mälust, kirjutab selle hoopis mällu:

Siinkohal saab mälu aadressil 1000h väärtuse ax. Kui see näide käivitatakse kohe pärast eelmist, siis on 2 baiti aadressidel 1000h ja 1001h 2 baiti täisarvu väärtusega 20.

Matemaatilisi või loogilisi operatsioone sooritavad käsud

Mõned juhised teevad selliseid asju nagu lahutamine või loogilised operatsioonid nagu mitte:

Selle artikli varasem masinakoodi näide oleks see assembleri keeles:

Siin liidetakse 42 ja ax kokku ja tulemus salvestatakse tagasi axi. x86 assembleris on ka võimalik ühendada mäluühendust ja matemaatilist operatsiooni selliselt:

See käsk lisab 1000h-sse salvestatud kahebaidilise täisarvu väärtuse ax-i ja salvestab vastuse ax-i.

See käsk arvutab registrite ax ja bx sisu või ja salvestab tulemuse tagasi axi.

Juhised, mis otsustavad, milline saab olema järgmine juhis

Tavaliselt täidetakse käsud selles järjekorras, milles nad ilmuvad mälus, mis on järjekorras, milles nad on sisestatud assemblerikoodis. Protsessor täidab neid lihtsalt üksteise järel. Kuid selleks, et protsessorid saaksid teha keerulisi asju, peavad nad täitma erinevaid käske vastavalt neile antud andmetele. Protsessorite võimet täita erinevaid käske sõltuvalt millegi tulemusest nimetatakse hargnemiseks. Juhiseid, mis otsustavad, milline peaks olema järgmine juhis, nimetatakse hargnemisjuhisteks.

Oletame, et keegi soovib arvutada värvikoguse, mida ta vajab teatava küljepikkusega ruudu värvimiseks. Mastaabisäästu tõttu ei müü värvipood talle aga vähem värvi kui 100 x 100 suuruse ruudu värvimiseks vajalik kogus.

Selleks, et välja arvutada värvikogus, mida nad vajavad, lähtudes ruutude pikkusest, mida nad tahavad värvida, leiavad nad järgmised sammud:

• lahutatakse 100 küljepikkusest
• kui vastus on väiksem kui null, määrata külje pikkuseks 100.
• korrutatakse küljepikkus iseendaga

Seda algoritmi saab väljendada järgmise koodiga, kus ax on küljepikkus.

See näide tutvustab mitmeid uusi asju, kuid kaks esimest juhendit on tuttavad. Nad kopeerivad väärtuse ax väärtusesse bx ja seejärel lahutatakse bx-st 100.

Üks uus asi selles näites on nn silt, mis on assembleri keeltes üldiselt esinev mõiste. Märgistus võib olla mis tahes, mida programmeerija tahab (välja arvatud juhul, kui see on käsu nimi, mis ajab assembleri segadusse). Selles näites on silt 'continue'. Assembler tõlgendab seda kui käsu aadressi. Antud juhul on see mult axi aadress.

Teine uus kontseptsioon on lipud. x86-protsessoritel seavad paljud käsud protsessoris "lipud", mida järgmine käsk saab kasutada, et otsustada, mida teha. Antud juhul, kui bx oli väiksem kui 100, siis sub seab lipu, mis ütleb, et tulemus oli väiksem kui null.

Järgmine käsk on jge, mis on lühend sõnast 'Jump if Greater than or Equal to'. See on hargnemiskäsk. Kui protsessori lipud näitavad, et tulemus oli suurem või võrdne nulliga, siis järgmise käsu asemel hüppab protsessor järgmise käsu juurde, mis on mul ax.

See näide töötab hästi, kuid see ei ole see, mida enamik programmeerijaid kirjutaks. Subtraktsioonikäsk kehtestas lipu õigesti, kuid see muudab ka väärtust, millega ta töötab, mis nõudis, et ax kopeeritaks bx-sse. Enamik assemblerkeeli lubab võrdluskäsklusi, mis ei muuda ühtegi argumenti, mida neile edastatakse, kuid seavad lipud ikkagi õigesti ja x86 assembler ei ole erandiks.

Nüüd, selle asemel, et lahutada axist 100, vaadata, kas see arv on väiksem kui null, ja määrata see tagasi axile, jäetakse ax muutumatuks. Lipud seatakse endiselt samamoodi ja hüpe toimub endiselt samades olukordades.

Sisend ja väljund

Kuigi sisend ja väljund on arvutite põhiline osa, ei ole assembleri keeles ühte ja sama viisi, kuidas neid teha. Selle põhjuseks on see, et see, kuidas I/O töötab, sõltub arvuti seadistusest ja operatsioonisüsteemist, mitte ainult sellest, milline protsessor tal on. Näiteosas toodud Hello World näide kasutab MS-DOSi operatsioonisüsteemi kõnesid ja sellele järgnev näide kasutab BIOSi kõnesid.

On võimalik teha I/O-d assembleri keeles. Assembleri keel võib üldiselt väljendada kõike, mida arvuti suudab teha. Kuid kuigi assembleri keeles on olemas käsud lisamiseks ja hargnemiseks, mis teevad alati sama asja, ei ole assembleri keeles ühtegi käsku, mis teeksid alati I/O-d.

Oluline on märkida, et see, kuidas I/O töötab, ei ole osa ühestki assembleri keelest, sest see ei ole osa protsessori tööpõhimõtetest.

Kuigi assembleri keelt ei kasuta otseselt protsessor, vaid masinkood, on sellega siiski palju pistmist. Iga protsessoriperekond toetab erinevaid funktsioone, käske, reegleid selle kohta, mida käsud võivad teha, ja reegleid selle kohta, millised käskude kombinatsioonid on kus lubatud. Selle tõttu vajavad eri tüüpi protsessorid ikkagi erinevaid assemblerikeeli.

Kuna assembleri keele iga versioon on seotud protsessoriperekonnaga, puudub tal midagi, mida nimetatakse teisaldatavuseks. Midagi, mis on kaasaskantav või teisaldatav, saab hõlpsasti üle kanda ühest arvutitüübist teise. Kui muud tüüpi programmeerimiskeeled on teisaldatavad, siis assembleri keel üldiselt ei ole.

Kuigi assembleri keel võimaldab hõlpsasti kasutada kõiki protsessori funktsioone, ei kasutata seda tänapäevastes tarkvaraprojektides mitmel põhjusel:

• Lihtsa programmi väljendamine assembleris nõuab palju vaeva.
• Kuigi assembleri keel ei ole nii vigaohtlik kui masinkood, pakub see siiski väga vähe kaitset vigade eest. Peaaegu kõik assembleri keeled ei taga tüübikindlus.
• Assembleri keel ei soodusta häid programmeerimistavasid nagu modulaarsus.
• Kuigi iga üksikut assembleri käsku on lihtne mõista, on raske öelda, milline oli selle kirjutanud programmeerija kavatsus. Tegelikult on programmi assemblerikeelest nii raske aru saada, et ettevõtted ei muretse selle pärast, et inimesed oma programme lahti monteerivad (saavad assembleri keelest aru).

Nende puuduste tõttu kasutatakse enamikus projektides selle asemel kõrgetasemelisi keeli nagu Pascal, C ja C++. Need võimaldavad programmeerijatel oma ideid otsesemalt väljendada, selle asemel, et muretseda, kuidas protsessorile igal sammul öelda, mida ta peab tegema. Neid nimetatakse kõrgetasemeliseks, sest ideed, mida programmeerija saab sama palju koodiga väljendada, on keerulisemad.

Programmeerijad, kes kirjutavad koodi kompileeritud kõrgtasemelistes keeltes, kasutavad programmi, mida nimetatakse kompilaatoriks, et muuta oma kood assembleri keeleks. Kompilaatorite kirjutamine on palju raskem kui assemblerite kirjutamine. Samuti ei võimalda kõrgetasemelised keeled programmeerijatel alati kasutada kõiki protsessori funktsioone. See on tingitud sellest, et kõrgtasandi keeled on loodud nii, et nad toetavad kõiki protsessoriperekondi. Erinevalt assemblerikeeltest, mis toetavad ainult ühte tüüpi protsessoreid, on kõrgetasemelised keeled kaasaskantavad.

Kuigi kompilaatorid on keerulisemad kui assemblerid, on aastakümneid kestnud kompilaatorite valmistamine ja uurimine muutnud need väga heaks. Nüüd ei ole enamasti enam põhjust kasutada assemblerikeelt enamasti projektide jaoks, sest kompilaatorid oskavad tavaliselt sama hästi või paremini kui programmeerijad aru saada, kuidas programme assemblerkeeles väljendada.

x86 Assembleris kirjutatud programm Hello World:

Funktsioon, mis väljastab ekraanile numbri, kasutades BIOSi katkestusi, mis on kirjutatud NASM x86 assembleris. Modulaarkoodi on võimalik kirjutada assembleris, kuid see nõuab lisatööd. Pange tähele, et kõik, mis tuleb pärast semikoolonit real, on kommentaar ja assembler ignoreerib seda. Kommentaaride lisamine assembleri koodile on väga oluline, sest suuri assembleri programme on väga raske mõista.