Assembleertaal (assembly): definitie, werking en voorbeelden voor beginners

Toen computerwetenschappers voor het eerst programmeerbare machines bouwden, programmeerden ze die rechtstreeks in machinecode, een reeks getallen die de computer instrueerde wat hij moest doen. Machinetaal schrijven was erg moeilijk en duurde lang, dus uiteindelijk werd assemblagetaal gemaakt. Assembleertaal is gemakkelijker voor een mens om te lezen en kan sneller worden geschreven, maar het is nog steeds veel moeilijker voor een mens om te gebruiken dan een high-level programmeertaal die menselijke taal probeert na te bootsen.

Programmeren in machinecode

Om in machinecode te programmeren, moet de programmeur weten hoe elke instructie er binair (of hexadecimaal) uitziet. Hoewel het voor een computer gemakkelijk is om snel uit te vinden wat machinecode betekent, is het moeilijk voor een programmeur. Elke instructie kan verschillende vormen hebben, die er voor mensen allemaal uitzien als een hoop getallen. Elke fout die iemand maakt bij het schrijven van machinecode wordt pas opgemerkt wanneer de computer het verkeerde doet. De fout achterhalen is moeilijk omdat de meeste mensen niet kunnen zien wat machinecode betekent door ernaar te kijken. Een voorbeeld van hoe machinecode eruit ziet:

05 2A 00

Deze hexadecimale machinecode vertelt een x86-computerprocessor om 42 toe te voegen aan de accumulator. Het is zeer moeilijk voor een persoon om het te lezen en te begrijpen, zelfs als die persoon machinecode kent.

Assembleertaal gebruiken

In assembleertaal kan elke instructie worden geschreven als een kort woord, een mnemotechnisch woord genaamd, gevolgd door andere dingen zoals getallen of andere korte woorden. Het mnemonicum wordt gebruikt zodat de programmeur niet de exacte getallen in machinecode hoeft te onthouden die nodig zijn om de computer te vertellen iets te doen. Voorbeelden van mnemonics in assembleertaal zijn add, dat gegevens toevoegt, en mov, dat gegevens van de ene plaats naar de andere verplaatst. Omdat 'mnemonic' een ongebruikelijk woord is, wordt soms de term instructietype of gewoon instructie gebruikt, vaak ten onrechte. De woorden en cijfers na het eerste woord geven meer informatie over wat er moet gebeuren. Zo kan bijvoorbeeld na een optelling staan welke twee dingen bij elkaar moeten worden opgeteld en zeggen de dingen na mov wat moet worden verplaatst en waar het moet worden neergezet.

Bijvoorbeeld, de machinecode in de vorige sectie (05 2A 00) kan in assemblage worden geschreven als:

Assembleertaal stelt programmeurs ook in staat om de eigenlijke gegevens die het programma gebruikt op een eenvoudigere manier te schrijven. De meeste assemblagetalen hebben ondersteuning voor het eenvoudig maken van getallen en tekst. In machinecode zou elk verschillend type getal, zoals positief, negatief of decimaal, handmatig moeten worden omgezet in binair en tekst zou één letter per keer moeten worden gedefinieerd, als getallen.

Assemblagetaal biedt een zogenaamde abstractie van machinecode. Bij gebruik van assembly hoeven programmeurs niet in detail te weten wat getallen voor de computer betekenen; de assembler zoekt dat uit. Met assemblagetaal kan de programmeur eigenlijk nog steeds alle functies van de processor gebruiken die hij ook met machinecode zou kunnen gebruiken. In die zin heeft assemblagetaal een zeer goede, zeldzame eigenschap: het heeft hetzelfde vermogen om dingen uit te drukken als dat wat het abstraheert (machinecode), terwijl het veel gemakkelijker te gebruiken is. Daarom wordt machinecode bijna nooit gebruikt als programmeertaal.

Demontage en debugging

Wanneer programma's klaar zijn, zijn ze al omgezet in machinecode, zodat de processor ze daadwerkelijk kan uitvoeren. Soms echter, als het programma een fout bevat, willen programmeurs kunnen zien wat elk deel van de machinecode doet. Disassemblers zijn programma's die programmeurs daarbij helpen door de machinecode van het programma terug te zetten in assembleertaal, die veel gemakkelijker te begrijpen is. Disassemblers, die machinecode omzetten in assemblagetaal, doen het tegenovergestelde van assemblers, die assemblagetaal omzetten in machinecode.

Een begrip van hoe computers zijn georganiseerd, hoe ze op een zeer laag niveau lijken te werken, is nodig om te begrijpen hoe een assembleertaalprogramma werkt. Op het meest simplistische niveau hebben computers drie hoofdonderdelen:

1. hoofdgeheugen of RAM dat gegevens en instructies bevat,
2. een processor, die de gegevens verwerkt door de instructies uit te voeren, en
3. input en output (soms afgekort tot I/O), waarmee de computer kan communiceren met de buitenwereld en gegevens kan opslaan buiten het hoofdgeheugen, zodat hij de gegevens later weer kan ophalen.

Hoofdgeheugen

In de meeste computers is het geheugen opgedeeld in bytes. Elke byte bevat 8 bits. Elke byte in het geheugen heeft ook een adres, een getal dat aangeeft waar de byte zich in het geheugen bevindt. De eerste byte in het geheugen heeft het adres 0, de volgende heeft het adres 1, enzovoort. Door het geheugen in bytes te verdelen is het per byte adresseerbaar omdat elke byte een uniek adres krijgt. Adressen van bytegeheugens kunnen niet worden gebruikt om te verwijzen naar een enkele bit van een byte. Een byte is het kleinste stukje geheugen dat kan worden geadresseerd.

Hoewel een adres verwijst naar een bepaalde byte in het geheugen, kunnen processoren meerdere bytes van het geheugen achter elkaar gebruiken. Het meest gebruikelijke gebruik van deze mogelijkheid is het gebruik van 2 of 4 bytes op een rij om een getal, meestal een geheel getal, weer te geven. Enkele bytes worden soms ook gebruikt om gehele getallen weer te geven, maar omdat ze slechts 8 bits lang zijn, kunnen ze slechts 2⁸ of 256 verschillende mogelijke waarden bevatten. Door 2 of 4 bytes op een rij te gebruiken, wordt het aantal verschillende mogelijke waarden verhoogd tot respectievelijk 2¹⁶ , 65536 of 2³² , 4294967296.

Wanneer een programma een byte of een aantal bytes achter elkaar gebruikt om iets als een letter, cijfer of iets anders voor te stellen, worden die bytes een object genoemd omdat ze allemaal deel uitmaken van hetzelfde ding. Hoewel objecten allemaal worden opgeslagen in identieke bytes van het geheugen, worden ze behandeld alsof ze een "type" hebben, dat zegt hoe de bytes moeten worden opgevat: als een geheel getal of een teken of een ander type (zoals een niet-integere waarde). Machinecode kan ook worden beschouwd als een type dat wordt geïnterpreteerd als instructies. Het begrip type is zeer, zeer belangrijk omdat het bepaalt welke dingen wel en niet kunnen worden gedaan met het object en hoe de bytes van het object moeten worden geïnterpreteerd. Het is bijvoorbeeld niet geldig om een negatief getal op te slaan in een object met een positief getal en het is niet geldig om een breuk op te slaan in een geheel getal.

Een adres dat wijst naar (het adres is van) een multi-byte object is het adres van de eerste byte van dat object - de byte met het laagste adres. Terzijde: een belangrijk punt is dat u aan het adres van een object niet kunt zien wat het type ervan is - of zelfs hoe groot het is. In feite kunt u zelfs niet zeggen welk type een object is door ernaar te kijken. Een assembleertaalprogramma moet bijhouden welke geheugenadressen welke objecten bevatten, en hoe groot die objecten zijn. Een programma dat dit doet is typeveilig, omdat het alleen dingen doet met objecten die veilig zijn om te doen op basis van hun type. Een programma dat dat niet doet, zal waarschijnlijk niet goed werken. Merk op dat de meeste programma's niet expliciet opslaan wat het type van een object is, ze benaderen objecten gewoon consistent - hetzelfde object wordt altijd behandeld als hetzelfde type.

De processor

De processor voert instructies uit, die als machinecode zijn opgeslagen in het hoofdgeheugen. De meeste processoren hebben niet alleen toegang tot het geheugen voor opslag, maar ook een paar kleine, snelle ruimten van vaste grootte voor het bewaren van objecten waarmee op dat moment wordt gewerkt. Deze ruimtes worden registers genoemd. Processoren voeren gewoonlijk drie typen instructies uit, hoewel sommige instructies een combinatie van deze typen kunnen zijn. Hieronder staan enkele voorbeelden van elk type in x86-assemblagetaal.

Instructies die geheugen lezen of schrijven

De volgende x86-assemblagetaalinstructie leest (laadt) een object van 2 bytes op adres 4096 (0x1000 in hexadecimaal) in een 16-bits register genaamd 'ax':

In deze assemblagetaal betekenen vierkante haakjes rond een getal (of een registernaam) dat het getal moet worden gebruikt als een adres naar de gegevens die moeten worden gebruikt. Het gebruik van een adres om naar gegevens te verwijzen wordt indirection genoemd. In het volgende voorbeeld, zonder de vierkante haakjes, wordt in een ander register, bx, de waarde 20 geladen.

Omdat er geen indirectie werd gebruikt, werd de werkelijke waarde zelf in het register gezet.

Als de operanden (de dingen die achter het mnemotechnisch teken komen) in omgekeerde volgorde verschijnen, schrijft een instructie die iets uit het geheugen laadt, het in plaats daarvan naar het geheugen:

Hier krijgt het geheugen op adres 1000h de waarde van bx. Als dit voorbeeld direct na het vorige wordt uitgevoerd, zijn de 2 bytes op 1000h en 1001h een geheel getal van 2 bytes met de waarde 20.

Instructies die wiskundige of logische bewerkingen uitvoeren

Sommige instructies doen dingen zoals aftrekken of logische bewerkingen zoals niet:

Het machinecodevoorbeeld eerder in dit artikel zou dit zijn in assemblagetaal:

Hier worden 42 en ax opgeteld en het resultaat wordt weer in ax opgeslagen. In x86 assembly is het ook mogelijk om een geheugentoegang en een wiskundige bewerking als deze te combineren:

Deze instructie telt de waarde van het gehele getal van 2 bytes opgeslagen op 1000h op bij ax en slaat het antwoord op in ax.

Deze instructie berekent de or van de inhoud van de registers ax en bx en slaat het resultaat op in ax.

Instructies die bepalen wat de volgende instructie wordt

Gewoonlijk worden instructies uitgevoerd in de volgorde waarin ze in het geheugen staan, dat is de volgorde waarin ze in de assemblagecode zijn getypt. De processor voert ze gewoon achter elkaar uit. Om processoren echter ingewikkelde dingen te laten doen, moeten ze verschillende instructies uitvoeren op basis van de gegevens die ze hebben gekregen. Het vermogen van processoren om verschillende instructies uit te voeren, afhankelijk van de uitkomst van iets, wordt branching genoemd. Instructies die beslissen wat de volgende instructie moet zijn, worden branch-instructies genoemd.

Stel dat iemand in dit voorbeeld wil berekenen hoeveel verf hij nodig heeft om een vierkant met een bepaalde zijde te schilderen. Vanwege schaalvoordelen zal de verfwinkel hem echter niet minder verkopen dan de hoeveelheid verf die nodig is om een vierkant van 100 x 100 te schilderen.

Om uit te rekenen hoeveel verf zij nodig hebben op basis van de lengte van het vierkant dat zij willen schilderen, bedenken zij deze reeks stappen:

• trek 100 af van de lengte van de zijde
• indien het antwoord kleiner is dan nul, stel de lengte van de zijde in op 100
• vermenigvuldig de lengte van de zijde met zichzelf

Dat algoritme kan worden uitgedrukt in de volgende code waarbij ax de lengte van de zijde is.

Dit voorbeeld introduceert verschillende nieuwe dingen, maar de eerste twee instructies zijn bekend. Zij kopiëren de waarde van ax naar bx en trekken vervolgens 100 af van bx.

Een van de nieuwe dingen in dit voorbeeld heet een label, een concept dat in assemblagetalen in het algemeen voorkomt. Labels kunnen alles zijn wat de programmeur wil (tenzij het de naam van een instructie is, wat de assembler in verwarring zou brengen). In dit voorbeeld is het label "doorgaan". Het wordt door de assembler geïnterpreteerd als het adres van een instructie. In dit geval is het het adres van mult ax.

Een ander nieuw concept is dat van de vlaggen. Op x86-processoren zetten veel instructies "vlaggen" in de processor die door de volgende instructie kunnen worden gebruikt om te beslissen wat er moet gebeuren. In dit geval, als bx minder dan 100 was, zal sub een vlag zetten die zegt dat het resultaat minder dan nul was.

De volgende instructie is jge, een afkorting van "jump if greater than or equal to". Het is een vertakkingsinstructie. Als de flags in de processor aangeven dat het resultaat groter is dan of gelijk aan nul, springt de processor, in plaats van naar de volgende instructie, naar de instructie bij het vervolglabel, dat is mul ax.

Dit voorbeeld werkt prima, maar het is niet wat de meeste programmeurs zouden schrijven. De aftrek-instructie zet de vlag correct, maar verandert ook de waarde waarop het werkt, waardoor de ax in bx moest worden gekopieerd. De meeste assemblagetalen staan vergelijkingsinstructies toe die geen van de doorgegeven argumenten veranderen, maar toch de vlaggen correct instellen, en x86 assemblage is daarop geen uitzondering.

Nu, in plaats van 100 af te trekken van ax, te kijken of dat getal kleiner is dan nul, en het terug toe te wijzen aan ax, wordt ax ongewijzigd gelaten. De vlaggen worden nog steeds op dezelfde manier ingesteld, en de sprong wordt nog steeds gemaakt in dezelfde situaties.

Invoer en uitvoer

Hoewel invoer en uitvoer een fundamenteel onderdeel zijn van computergebruik, is er niet één manier waarop dit gebeurt in assembleertaal. Dat komt omdat de manier waarop I/O werkt afhangt van de instelling van de computer en het besturingssysteem dat erop draait, en niet alleen van het soort processor. In het onderstaande voorbeeldgedeelte gebruikt het Hello World-voorbeeld MS-DOS-besturingssysteemaanroepen en het voorbeeld erna BIOS-aanroepen.

Het is mogelijk om I/O te doen in assembleertaal. Assembleertaal kan in het algemeen alles uitdrukken wat een computer kan doen. Maar hoewel er in assembleertaal instructies zijn om toe te voegen en te vertakken die altijd hetzelfde doen, zijn er geen instructies in assembleertaal die altijd I/O doen.

Het is belangrijk op te merken dat de manier waarop I/O werkt geen deel uitmaakt van een assemblagetaal, omdat het geen deel uitmaakt van hoe de processor werkt.

Hoewel assembleertaal niet rechtstreeks door de processor wordt uitgevoerd - machinecode wel - heeft het er toch veel mee te maken. Elke processorfamilie ondersteunt verschillende functies, instructies, regels voor wat de instructies kunnen doen, en regels voor welke combinatie van instructies waar is toegestaan. Daarom hebben verschillende soorten processoren nog steeds verschillende assemblagetalen nodig.

Omdat elke versie van assembleertaal gebonden is aan een processorfamilie, ontbreekt het aan iets dat overdraagbaarheid wordt genoemd. Iets dat overdraagbaar is, kan gemakkelijk worden overgezet van het ene type computer naar het andere. Terwijl andere soorten programmeertalen overdraagbaar zijn, is assemblagetaal dat in het algemeen niet.

Hoewel assembleertaal een gemakkelijke manier is om alle functies van de processor te gebruiken, wordt het om verschillende redenen niet gebruikt voor moderne softwareprojecten:

• Het kost veel moeite om een eenvoudig programma in assembly uit te drukken.
• Hoewel niet zo foutgevoelig als machinecode, biedt assemblagetaal nog steeds weinig bescherming tegen fouten. Bijna alle assemblagetalen dwingen geen typeveiligheid af.
• Assembleertaal bevordert geen goede programmeerpraktijken zoals modulariteit.
• Hoewel elke afzonderlijke instructie in assembleertaal gemakkelijk te begrijpen is, is het moeilijk te achterhalen wat de bedoeling was van de programmeur die de instructie schreef. In feite is de assemblagetaal van een programma zo moeilijk te begrijpen dat bedrijven zich geen zorgen maken over mensen die hun programma's demonteren (de assemblagetaal achterhalen).

Als gevolg van deze nadelen worden voor de meeste projecten high-level talen zoals Pascal, C en C++ gebruikt. Met deze talen kunnen programmeurs hun ideeën directer uitdrukken, in plaats van dat ze de processor bij elke stap moeten vertellen wat hij moet doen. Ze worden high-level genoemd omdat de ideeën die de programmeur in dezelfde hoeveelheid code kan uitdrukken ingewikkelder zijn.

Programmeurs die code schrijven in gecompileerde high level talen gebruiken een programma, een compiler genaamd, om hun code om te zetten in assemblagetaal. Compilers zijn veel moeilijker te schrijven dan assemblers. Ook kunnen programmeurs met high-level talen niet altijd alle functies van de processor gebruiken. Dit komt doordat high-level talen zijn ontworpen om alle processorfamilies te ondersteunen. In tegenstelling tot assemblagetalen, die slechts één type processor ondersteunen, zijn high-level talen overdraagbaar.

Ook al zijn compilers ingewikkelder dan assemblers, tientallen jaren van maken en onderzoeken van compilers heeft ze zeer goed gemaakt. Nu is er niet veel reden meer om assemblagetaal te gebruiken voor de meeste projecten, omdat compilers meestal even goed of beter kunnen uitzoeken hoe programma's in assemblagetaal moeten worden uitgedrukt dan programmeurs.

Een Hello, world! programma geschreven in x86 assemblage:

Een functie die een getal afdrukt naar het scherm met behulp van BIOS interrupts, geschreven in NASM x86 assemblage. Het is mogelijk modulaire code te schrijven in assembly, maar dat kost extra moeite. Merk op dat alles wat na een puntkomma op een regel komt, commentaar is en door de assembler wordt genegeerd. Het plaatsen van commentaar in assembleertaalcode is erg belangrijk omdat grote assembleertaalprogramma's zo moeilijk te begrijpen zijn.

• Michael Singer, PDP-11. Assembler Language Programming and Machine Organization, John Wiley & Sons, NY: 1980.
• Peter Norton, John Socha, Peter Norton's Assembly Language Book for the IBM PC, Brady Books, NY: 1986.
• Dominic Sweetman: Zie MIPS Run. Morgan Kaufmann Publishers, 1999. ISBN 1-55860-410-3
• John Waldron: Inleiding tot RISC-assemblagetaalprogrammering. Addison Wesley, 1998. ISBN 0-201-39828-1
• Jeff Duntemann: Assemblagetaal stap voor stap. Wiley, 2000. ISBN 0-471-37523-3
• Paul Carter: PC assemblagetaal. Gratis ebook, 2001.
   Website
• Robert Britton: MIPS assemblagetaal programmeren. Prentice Hall, 2003. ISBN 0-13-142044-5
• Randall Hyde: De kunst van assemblagetaal. No Starch Press, 2003. ISBN 1-886411-97-2
  Conceptversies online beschikbaar Archived 2011-01-28 at the Wayback Machine as PDF and HTML.
• Jonathan Bartlett: Programmeren vanaf de grond. Uitgeverij Bartlett, 2004. ISBN 0-9752838-4-7
  Online beschikbaar als PDF en als HTML
• ASM Community Book "Een online boek vol nuttige ASM-informatie, tutorials en codevoorbeelden" door de ASM-gemeenschap.

Software

• MenuetOS - Besturingssysteem volledig geschreven in 64-bit assemblagetaal
• SB-Assembler voor de meeste 8-bit processoren/controllers
• GNU lightning, een bibliotheek die assembleertaalcode genereert tijdens de uitvoering, wat nuttig is voor Just-In-Time compilers.
• WinAsm Studio, The Assembly IDE - Free Downloads, Source Code , een gratis Assembly IDE, veel open source programma's om te downloaden en een populaire Board Archived 2008-08-05 at the Wayback Machine
• De Netwide Assembler
• GoAsm - een gratis component "Go" tools: ondersteuning 32-bit & 64-bit Windows programmering