Wat is een assembler taal?

Een assembler taal is een programmeertaal op laag niveau (2e generatie) die is ontworpen voor een specifiek type processor.  We kunnen het produceren door broncode van een programmeertaal op hoger niveau (zoals C / C ++) te compileren. Maar we kunnen ook zelf programma’s in deze taal schrijven. Assembler code kunnen we op zijn beurt weer omzetten in machinecode met behulp van een assembler.

Een assembler is een programma dat de computer draait en instructies omzet in een patroon van bits. De processor kan deze gebruiken om basisbewerkingen uit te voeren. Sommige mensen noemen deze instructies assembler-taal en anderen gebruiken de term assembleertaal .

Waar passen we assembler in de IT toe?

Elke computer heeft een processor die de rekenkundige, logische en controleactiviteiten van de computer uitvoert.

Elke familie van processors heeft zijn eigen set instructies voor het verwerken van verschillende bewerkingen, zoals invoer van het toetsenbord, informatie op het scherm weergeven en verschillende andere taken uitvoeren. Deze reeks instructies noemer we ‘machinetaal instructies’.

Een processor begrijpt alleen machinetaal instructies, die reeksen van enen en nullen zijn. Machinetaal is echter te obscuur en complex om in te zetten voor het ontwikkelen van software. Dus de assembler taal is ontworpen voor een specifieke familie van processors die verschillende instructies in symbolische code en een meer begrijpelijke vorm vertegenwoordigen.

De assemblertaal is de symbolische programmeertaal die qua vorm en inhoud het dichtst bij de machinetaal ligt. De assembler-taal is handig wanneer:

• We de stappen van ons programma nauwkeurig moeten beheersen, tot op byte- en zelfs op bitniveau.
• We subroutines moeten schrijven voor functies die niet worden geleverd door andere symbolische programmeertalen, zoals COBOL, Java of C.

Dit is hoe een assembler werkt

• Computers worden geleverd met een specifieke set basisinstructies die overeenkomen met de basishandelingen die de computer kan uitvoeren. Een “Load” -instructie zorgt er bijvoorbeeld voor dat de processor een reeks bits verplaatst van een locatie in het geheugen van de processor naar een speciale bewaarplaats, die we een register noemen.
• De programmeur kan een programma schrijven met behulp van een reeks van deze assembler-instructies.
• Deze opeenvolging van assembler-instructies, bekend als de broncode of het bronprogramma, wordt vervolgens gespecificeerd in het assemblerprogramma wanneer dat we programma starten.
• Het assemblerprogramma neemt elke programma-instructie in het bronprogramma en genereert een corresponderende bitstroom of patroon (een reeks nullen en enen van een bepaalde lengte).
• De uitvoer van het assemblerprogramma wordt de objectcode of objectprogramma genoemd ten opzichte van het invoerbronprogramma. De reeks nullen en enen die het objectprogramma vormen, noemen we ook wel machinecode.
• Het objectprogramma kunnen we vervolgens op elk gewenst moment uitvoeren.

De assembler-taal bestaat uit statements die instructies of comments vertegenwoordigen. De instructie statements zijn het werkende deel van de taal en zijn onderverdeeld in de volgende drie groepen:

• Machine-instructies.
• Instructies voor de assembler.
• Macro-instructies.

Hoe passen we assemblercode toe?

Aangezien de meeste compilers broncode direct naar machinecode converteren, maken softwareontwikkelaars vaak programma’s zonder de assembler taal te gebruiken. In sommige gevallen kunnen we assemblercode echter gebruiken om een ​​programma nauwkeurig af te stemmen. Een programmeur kan bijvoorbeeld een specifiek proces in assembler taal schrijven om ervoor te zorgen dat het zo efficiënt mogelijk werkt.

Hoewel assembler talen verschillen verschillen per processor architectuur, hebben ze vaak overeenkomstige instructies en operators. Hieronder staan enkele voorbeelden van instructies die x86- processoren ondersteunen.

• MOV – verplaats data van de ene locatie naar de andere.
• ADD – voeg twee waarden aan elkaar toe.
• SUB – trek een waarde af van een andere waarde.
• PUSH – duw data naar een stack.
• POP – pop-gegevens uit een stack.
• JMP – spring naar een andere locatie.
• INT – een proces onderbreken.

De volgende eenvoudige assemblercode kunnen we gebruiken om de cijfers 3 en 4 op te tellen:

mov eax, 3 – laadt 3 in het register “eax”.
mov ebx, 4 – laadt 4 in het register “ebx”.
add eax, ebx, ecx – tel “eax” en “ebx” bij elkaar op en sla het resultaat (7) op in ” ecx”.

Het schrijven van een programma in assembler is echter een moeizaam proces. Dat komt omdat iedere bewerking op een zeer eenvoudig niveau moet worden uitgevoerd. Hoewel het waarschijnlijk niet nodig is om assemblercode ooit toe te passen om een ​​computerprogramma te maken, maakt het leren van assembler taal wel vaak deel uit van een informatica curriculum omdat het nuttig inzicht biedt in de manier waarop processors werken.

Voordelen van assembler taal

Kennis van deze basale taal maakt je bewust van hoe:

• Programma’s samenwerken met OS, processor en BIOS.
• Gegevens worden weergegeven in het geheugen.
• De processor instructies uitvoert.
• Instructies gegevens verwerken.
• Een programma toegang krijgt tot externe apparaten.

Voordelen van het gebruik van assembler taal zijn:

• Vereist minder geheugen en uitvoeringstijd.
• Assembler maakt hardwarespecifieke complexe taken op een eenvoudiger manier mogelijk.
• Is geschikt voor tijdkritische taken.
• Is het meest geschikt voor het schrijven van onderbrekingsroutines en andere geheugenresidente programma’s.

Moet we een assembler taal leren?

Of we assembler taal moeten leren, hangt af van ons werk. Voor de meeste ontwikkelaars is het antwoord ‘nee’.

Er zijn namelijk twee primaire redenen om assembler taal te leren: omdat we het zelf moeten gebruiken of omdat we computers op een fundamenteel niveau willen begrijpen.

Vanuit praktisch oogpunt gebruikt slechts een handjevol ingenieurs en computerwetenschappers assembler.

De overgrote meerderheid van softwareontwikkelaars, waaronder vrijwel alle applicatie-ontwikkelaars, maakt gebruik van programmeertalen van hoog niveau en geen assemblercode. Enkele specifieke gebieden waar we echter wel assembler taal voor gebruiken zijn:

• Besturingssystemen.
• Firmware.
• Apparatuur programma’s.
• Het ontwerpen van programmeertalen.
• Ontwerpen van compilers.
• Embedded systemen.
• Hardware ontwerp.
• Geavanceerde cryptografie.
• Theoretische informatica.

De andere reden om assembler te leren, is om een ​​beter begrip te krijgen van wat er diep in het inwendige van een computer gebeurt. (Dit is de reden waarom vrijwel alle IT-ers deze taal krijgen tijdens hun opleiding.)

Als je iemand bent die graag in computers duikt en echt in techniek geïnteresseerd is, overweeg je misschien een carrière in het ontwikkelen van systemen op laag niveau.

Assembler taal codegeneratie

Een codegenerator vertaalt de uitvoer van de syntaxanalysator en/of semantische analysator naar code op een lager niveau, zoals bijvoorbeeld assembler taal.

Het eerste deel van een compiler analyseert de broncode tot een structuur die de betekenis van het programma draagt. Deze structuur is over het algemeen de abstracte syntaxisboom die is gecontroleerd en gedecodeerd. Vergeet bovendien niet dat gedecodeerd betekent dat alle identificatiereferenties zijn toegekend.

Vanuit deze structuur kunnen we tevens de bijbehorende code genereren in een andere taal, de doeltaal. Dit is wat een codegenerator doet.

Sommige compilers genereren twee keer: ze genereren eerst code in een “tussentaal” zoals SIL, LLVM IR, HIR, MIR, CIL, enzovoorts. Daarna voeren ze de “echte” codegeneratie in een doeltaal uit die we direct kunnen uitvoeren zoals virtuele machinecode, assembler taal of machinetaal.

Doelen van codegeneratie

Dit zijn de drie doelen van een goede codegenerator:

• Het zou de juiste code moeten produceren.
• De generator zou efficiënte code moeten produceren.
• Het moet efficiënte code opleveren.

Andere dingen om te leren

Een nieuwer idee op het gebied van programmavoorbereiding en portability is het concept van een virtuele machine . Met behulp van de Java- programmeertaal worden taalinstructies bijvoorbeeld gecompileerd tot een generieke vorm van machinetaal die bekend staat als bytecode en die kan worden uitgevoerd door een virtuele machine, een soort theoretische machine die de meeste computerbewerkingen benadert. De bytecode kan vervolgens worden verzonden naar elk computerplatform dat eerder is gedownload of ingebouwd in de virtuele Java-machine. De virtuele machine is op de hoogte van de specifieke instructielengtes en andere bijzonderheden van het platform en zorgt ervoor dat de Java-bytecode kan draaien.

Er zijn enkele talen waar we, als we er maar iets van weten, al heel veel kunnen doen. Python en Ruby zijn zo, we kunnen er in een weekend al genoeg over leren om iets waardevols te bouwen. Assembler taal is niet zo.

Assembler taal gebruiken we nooit op zichzelf, maar altijd op een specifiek platform. Het type ingenieur dat assembler moet kennen, werkt waarschijnlijk in een gebied waar het nodig is om ook andere vaardigheden te kennen om effectief te zijn. Deze omvatten waarschijnlijk:

• Hardwaretalen, zoals VHDL en Verilog, samen met een goed begrip van microprocessors en elektrotechniek.
• Low-level besturingssysteem talen zoals C en zijn afgeleiden: C ++, C # en D.
• Oude talen zoals Fortran en Cobol.
• Platformtalen zoals Java en Objective-C.
• Algoritmes.

Discussieer mee op LinkedIn.