Llenguatge d'assemblador
 | |
| Tipus | llenguatge de programació  |
|---|---|
| Data de creació | 1949 |
| Paradigma de programació | non-structured programming (en)  |
| Extensió dels fitxers | asm i s |
| Etiqueta d'Stack Exchange | Etiqueta |
Un llenguatge d'assemblador (en anglès assembly language i l'abreviació asm) és un llenguatge de programació de baix nivell.[1] Consisteix en un conjunt de mnemònics que representen instruccions bàsiques del processador, que tenen una correspondència pràcticament d'un a un entre les instruccions en assemblador i les instruccions del codi màquina de l'arquitectura. Així, cada arquitectura de processador té el seu propi llenguatge assemblador, a diferència de la majoria de llenguatges de programació d'alt nivell, que solen ser portables a través de múltiples arquitectures però requereixen, llavors, ser interpretats o compilats.[2][3]
Un programa utilitari anomenat assemblador és usat per traduir sentències del llenguatge assemblador al codi de màquina del computador objectiu. L'assemblador realitza una traducció més o menys isomorfa (un mapatge d'un a un) des de les sentències mnemòniques a les instruccions i dades de màquina. Això està en contrast amb els llenguatges d'alt nivell, en els quals una sola declaració generalment dona lloc a moltes instruccions de màquina.
Molts sofisticats assembladors ofereixen mecanismes addicionals per facilitar el desenvolupament del programa, controlar el procés d'assemblatge, i l'ajuda de depuració. Particularment, la majoria dels assembladors moderns inclouen una facilitat de macro (descrita més a baix), i es diuen macro assembladors.
Va ser usat principalment en els inicis del desenvolupament de programari, quan encara no es comptava amb potents llenguatges d'alt nivell i els recursos eren limitats. Actualment s'utilitza amb freqüència en ambients acadèmics i d'investigació, especialment quan es requereix la manipulació directa de maquinari, alt rendiment, o un ús de recursos controlat i reduït. També és utilitzat en el desenvolupament de controladors de dispositiu (en anglès, device drivers) i en el desenvolupament de sistemes operatius, a causa de la necessitat de l'accés directe a les instruccions de la màquina. Molts dispositius programables (com els microcontroladors) encara compten amb l'assemblador com l'única manera de ser manipulats.
Història
[modifica]La primera versió d'un codi de llenguatge assemblador es troba a l'obra de 1947 Coding for A.R.C. del matrimoni de matemàtics Kathleen Booth i Andrew Donald Booth.[4]
Els llenguatges d'assemblador, considerats llenguatges de segona generació, van ser creats durant la dècada de 1950. La seva facilitat respecte als llenguatges de primera generació era òbvia. No era el mateix recordar 10110000 01100001 (llenguatge màquina), que MOV AL, 0x61 (llenguatge d'assemblador).
Inicialment la traducció assemblador-màquina havia de fer-se a mà, però aviat van aparèixer programes traductors (degut en part a la forma exageradament mecànica de la traducció). Més endavant van sergairebé arraconats pels llenguatges de tercera generació que reduïen la complexitat dels programes i la dependència en l'arquitectura de la màquina.
Els seus principals inconvenients són:
- La complexitat creix exponencialment com més gran sigui el programa.
- És dependent de l'arquitectura del processador.
El seu principal avantatge és la seva eficiència d'execució.
Actualment només es fan servir per fer programes que interaccionin directament amb el maquinari o amb un gran requeriment d'eficiència.
Els llenguatges d'assemblador van ser desenvolupats per primer cop als anys 1950, quan van ser referits com a llenguatges de programació de segona generació. Per exemple, el SOAP (Symbolic Optimal Assembly Program) era un llenguatge d'assemblador de 1957 per al computador IBM 650. Els llenguatges d'assemblador van eliminar molta de la propensió a errors i del consum de temps de la programació dels llenguatges de primera generació, que es necessitava amb els primers computadors, alliberant als programadors del tedi de recordar codis numèrics i càlculs de direcció. Durant un temps van ser àmpliament utilitzats per a tota mena de programació. Tanmateix, durant els anys 1980 (1990 en els microcomputadors), el seu ús havia sigut en gran part suplantat pels llenguatges d'alt nivell, en la cerca d'una productivitat millorada en programació.
Avui en dia, tot i que els llenguatges d'assemblador són majoritàriament gestionats i generats per compiladors, encara s'utilitzen per a la manipulació directa del maquinari, accés a instruccions especialitzades del processador, o per a resoldre problemes d'acompliment crític. Els usos típics són controlables/conductors (drivers) de dispositius, sistemes encastats de baix nivell, i sistemes de temps real.
Històricament, un gran nombre de programes han sigut escrit completament en llenguatges d'assemblador. Els sistemes operatius van ser quasi exclusivament escrits en llenguatges d'assemblador fins l'àmplia acceptació del llenguatge de programació C en els anys 1970 i principis dels 1980. A més, moltes aplicacions comercials van ser escrites en llenguatges d'assemblador, incloent una gran quantitat del software escrit per grans corporacions per a mainframes d'IBM. Els llenguatges COBOL i FORTRAN van desplaçar molt d'aquest treball de forma eventual, tot i que un gran nombre de grans organitzacions van conservar les infraestructures d'aplicacions en llenguatges d'assemblador fins ben entrats els anys 90.
La majoria dels primers microcomputadors van confiar en els llenguatges d'assemblador codificant a mà, incloent la majoria dels sistemes operatius i de les grans aplicacions. Això es deu al fet que aquests sistemes tenien greus limitacions de recursos, van imposar idiosincràtiques arquitectures de memòria i de pantalla, i van proporcionar serveis de sistema limitats i amb errors. Cal destacar la falta de compiladors de primera classe de llenguatge d'alt nivell adequats per al ús en un microcomputador. Un factor psicològic també podria haver-hi tingut un paper important: la primera generació de programadors de microcomputadors va conservar una actitud d'aficionat.
En un context molt més comercial, les principals raons per a utilitzar els llenguatges d'assemblador era crear programes de mida i sobrecàrrega mínima, i major velocitat i confiabilitat.
Els típics exemples de programes grans en els llenguatges d'assemblador en aquell temps són els sistemes operatius IBM PC DOS i aplicacions primerenques com la full de càlcul Lotus 1-2-3, i quasi tots els jocs populars per a la família Atari 800 de computadors personals. Fins i tot als anys 1990, la majoria dels videojocs de consolar van ser escrits en assemblador, inclosa la majoria de jocs per a la Megra Drive/Genesis i el Super Nintendo Entertainment System. Segons alguns experts de la indústria, el llenguatge d'assemblador era el millor llenguatge de programació disponible per obtenir el millor acompliment del Sega Saturn, una consola per a la qual era notòriament desafiant desenvolupar i programar jocs. El popular joc de arcade NBA Jam (1993) n'és un altre exemple. L'assemblador ha sigut durant un llarg temps, el llenguatge de desenvolupament primari en els computadors Commodore 64, Atari ST, així com el ZX Spectrum. Això va ser així en gran part perquè els dialectes del BASIC en aquests sistemes oferien insuficient velocitat d'execució, així com característiques per aprofitar completament el maquinari disponible. Alguns sistemes, més notablement l'Amiga, fins i tot tenen IDEs amb característiques de depuració i macros molt avançats, com podrien ser el freeware ASM-One assemblar, comparables a les del Microsoft Visual Studio (el ASM-Uno precedeix a aquest).
L'assemblador per al VIC-20 va ser escrit per Don French i publicat per French Silk. Amb 1639 bytes de longitud, el seu autor creu que és més petit que s'ha escriut mai. L'assemblador suportava l'adreçament simbòlic usual i la definició de cadenen de caràcters o cadenes hexadecimals. També permetia expressions de direccions que podien combinar-se amb les operacions d'adició, subtracció, multiplicació, AND lògic, OR lògic, i exponenciació.
Característiques
[modifica]Els programes escrits en assemblador s'assemblen en fitxers objectes fent servir un programa assemblador. Aquest fitxer posteriorment s'enllaça, mitjançant un programa enllaçador, amb altres possibles llibreries o fitxers objecte formant un executable. Normalment els programes assemblador són capços d'enllaçar els executables, o venen acompanyats d'un programa enllaçador que s'encarrega de dur a terme la tasca.
El propòsit per al que s'han creat aquest tipus de llenguatges és el de facilitar l'escriptura de programes, ja que escriure directament en codi binari, que és l'únic codi assimilat per l'ordinador, és a la pràctica impossible. El llenguatge té una estreta relació amb l'arquitectura en què s'executa el programa.
El fet de diferenciar entre assemblar llenguatges d'assemblador i compilar qualsevol altre llenguatge és pel fet que el programa assemblador és molt més senzill, ja que en els casos més senzills només ha de traduir etiquetes pel codi binari corresponent a la instrucció, per altra banda els compiladors són molt més complexos, ja que han d'interpretar un llenguatge molt més proper a nosaltres, necessitant eines matemàtiques molt més complexes com teoria de llenguatges i expressions regulars per al reconeixement sintàctic del llenguatge en concret.
Per altra banda, un assemblador (de l'anglès assembler) es refereix al programa informàtic que s'encarrega de traduir aquest codi font simbòlic escrit en un llenguatge d'assemblador, en el fitxer objecte que conté el codi màquina, executable directament pel microprocessador pel qual s'ha generat. L'evolució dels llenguatges de programació a partir dels llenguatges d'assemblador va originar l'evolució d'aquests programes assembladors, que feien el mateix que avui dia es coneix com a compiladors. El programa llegeix el fitxer escrit en llenguatge d'assemblador i substitueix cadascun dels mnemotècnics que apareixen pel seu codi d'operació corresponent en sistema binari per la plataforma que es va escollir com a destí en les opcions específiques de l'assemblador.
Els fitxers de codi font en assemblador són fitxers de text ASCII i solen portar l'extensió .ASM
- El codi escrit en llenguatge d'assemblador posseeix una certa dificultat per a ser entès, ja que la seva estructura s'assembla al llenguatge de màquina, és a dir, és un llenguatge de baix nivell.
- El llenguatge d'assemblador és difícilment portable, és a dir, un codi escrit per a un microprocessador pot necessitar ser modificat per a ser utilitzat en una màquina diferent. Al canviar a una màquina amb una arquitectura diferent, generalment és necessari reescriure’l completament.
- Els programes fets per un programador expert en un llenguatge d'assemblador són generalment molt més ràpids i consumeixen menys recursos del sistema (memòria RAM i ROM) que el programa equivalent compilat des d'un llenguatge d'alt nivell. Al programar amb molta cura en llenguatge d'assemblador es poden crear programes que s'executen més ràpidament i ocupen menys espai que el amb el llenguatge d'alt nivell.
- Amb un llenguatge d'assemblador es té un control molt precís de les tasques realitzades per un microprocessador, pel que es poden crear segments de codi difícils i/o ineficients de programar en un llenguatge d'alt nivell, ja que, entre altres coses, en el llenguatge d'assemblador es disposa d'instruccions del CPU que generalment no estan disponibles en els llenguatges d'alt nivell.
- També es pot controlar el temps en què tarda una rutina en executar-se, i impedir que s'interrompi durant la seva execució.
Tipus de programes assembladors
[modifica]Podem distingir entre tres tipus d'assembladors:
- Assembladors bàsics. Són de molt baix nivell, i la seva feina consisteix bàsicament a oferir nombres simbòlics a les distintes instruccions, paràmetres i coses com les formes d'adreçament. A més, reconeix una sèrie de directives (o meta instruccions) que indiquen certs paràmetres de funcionament de l'assemblador.
- Assembladors modulars, o macro assembladors. Descendents dels assembladors bàsics, foren molt populars en les dècades dels 50 i els 60, abans de la generalització dels llenguatges d'alt nivell. Fan tot el que pot fer un assemblador, i a més a més proporcionen una sèrie de directives per definir i invocar macroinstruccions (o simplement, macros). Vegeu X86.
- Assembladors modulars 32-bits o d'alt nivell. Són assembladors que van aparèixer com a resposta a una nova arquitectura de processadors de 32 bits, molts d'ells mantenint la compatibilitat podent treballar amb programes amb estructures de 16 bits. A més a més de realitzar la mateixa feina que els anteriors, permetent també l'ús de macros, permetent utilitzar estructures de programació més complexes pròpies dels llenguatges d'alt nivell.
Exemples de llenguatge assemblador
[modifica]Exemple per a l'arquitectura x86
[modifica]El següent és un exemple del programa clàssic Hola món escrit per a l'arquitectura de processador x86 (sota el sistema operatiu DOS).
; ---------------------------------------------
; Programa que imprimeix un string en la pantalla
; ---------------------------------------------
.model small ; model de memòria
.stack ; segment del stack
.data ; segment de dades
Cadena1 DB 'Hola Món. ; string a imprimir (finalitzat a $)
.code ; segment del codi
; ---------------------------------------------
; Inici del programa
; ---------------------------------------------
programa:
; ----------------------------------------------------------------------------------------------
; inicia el segment de dades
; ----------------------------------------------------------------------------------------------
MOV AX, @data ; càrrega en AX la direcció del segment de dades
MOV DS, AX ; mou la direcció al registro de segment por mitjà de AX
; ----------------------------------------------------------------------------------------------
; Imprimeix un string en pantalla
; ----------------------------------------------------------------------------------------------
MOV DX, offset Cadena1 ; mou a DX la direcció del string a imprimir
MOV AH, 9 ; AH = codi per indicar al MS DOS que imprimeixi a la
; pantalla, el string en DS:DX
INT 21h ; crida al MS DOS para executar la funció (en aquest
; cas especificada a AH)
; ----------------------------------------------------------------------------------------------
; Finalitza el programa
; ----------------------------------------------------------------------------------------------
INT 20h ; crida al MS DOS para finalitzar el programa
end programa
Exemple pel computador virtual (POCA)
[modifica]Una selecció d'instruccions per a una computadora virtual) amb les corresponents direccions de memòria en les quals se situaran les instruccions.[5] Aquestes direccions NO són estàtiques. Cada instrucció s'acompanya del codi en llenguatge assemblador generat (codi objecte) que coincideix amb l'arquitectura de computador virtual, o conjunt d'instruccions ISA.
| Dir. | Etiqueta | Instrucció | Codi màquina[6] |
|---|---|---|---|
| .begin | |||
| .org 2048 | |||
| a_start | .equ 3000 | ||
| 2048 | ld [length], %r1 | ||
| 2064 | be doni | 00000010 10000000 00000000 00000110 | |
| 2068 | addcc %r1,-4,%r1 | 10000010 10000000 01111111 11111100 | |
| 2072 | addcc %r1,%r2,%r4 | 10001000 10000000 01000000 00000010 | |
| 2076 | ld %r4,%r5 | 11001010 00000001 00000000 00000000 | |
| 2080 | ba loop | 00010000 10111111 11111111 11111011 | |
| 2084 | addcc %r3,%r5,%r3 | 10000110 10000000 11000000 00000101 | |
| 2088 | doni: | jmpl %r15+4,%r0 | 10000001 11000011 11100000 00000100 |
| 2092 | length: | 20 | 00000000 00000000 00000000 00010100 |
| 2096 | address: | a_start | 00000000 00000000 00001011 10111000 |
| .org a_start | |||
| 3000 | a: |
Exemple pell computador virtual (ARC)
[modifica]ARC és un subconjunt del model d'arquitectura basat en el processador SPARC. ARC (A RISC Computer) conté la majoria de les característiques importants de l'arquitectura SPARC.
| Direcció | Etiqueta | Instrucció | Comentaris |
|---|---|---|---|
| .begin | |||
| .org 2048 | |||
| a_start: | .equ 3000 | ! Direcció de memòria de l'arranjament comença en 3000 | |
| 2048 | ld [lenght], %r1 | ! S'estableix la longitud de l'arranjament en el registre | |
| 2052 | ld [address], %r2 | ! Direcció de l'arranjament | |
| 2056 | anddcc %r3, %r0, %r3 | ! S'estableix amb zero la suma parcial | |
| 2060 | loop: | anddcc %r1, %r1, %r0 | ! Verifico si r1 té elements restants |
| 2064 | be doni | ||
| 2068 | addcc %r1, -4, %r1 | !Decrement la grandària de l'arranjament | |
| 2072 | ld %r1 + %r2, %r4 | !Carrego el pròxim element en r4 | |
| 2076 | addcc %r3, %r4, %r3 | ! Actualitzo la suma parcial en r3 | |
| 2080 | ba loop | ! Torna a verificar la condició de tall | |
| 2084 | doni: | jmpl %r15 + 4, %r0 | ! Retorn a la rutina principal |
| 2088 | lenght: | 20 | ! Grandària de l'array en 20 bytes, 5 números |
| 2092 | address: | a_start | |
| .org a_start | ! Començament de l'array | ||
| a: | 25 | ||
| 15 | |||
| -20 | |||
| -35 | |||
| 15 | |||
| .end | ! Fi del programa |
Exemple pel µC Intel 8051
[modifica]Codi en llenguatge assemblador pel µC Intel 80C51:
ORG 8030H
include
T05SEG:
SETB TR0
JNB uSEG,T05SEG ; aquesta subrutina és utilitzada
CLR TR0 ; per realitzar una compta de
CPL uSEG ; 0,5 segons mitjaçant la
MOV R1,DPL ; interrupció del timer 0.
INVOKE
MOV R2,DPH
CJNE R2,#07H,T05SEG
CJNE R1,#78H,T05SEG
MOV DPTR,#0
RET
Exemple per al Microxip PIC16F84
[modifica]Codi en llenguatge assemblador pel microcontrolador 16F84 de Microxip:
ORG 0
Inici
bcf STATUS,RP0
clrf PORTB
movlw 0xFF
movwf PORTA
bsf STATUS,RP0
Principal
movf PORTA,W
movwf Comptador
movf Comptador,F
btfsc STATUS,Z
goto PuntDecimal
sublw d'9'
btfss STATUS,C
END
Referències
[modifica]- ↑ «Llenguatge d'assemblador». Cercaterm. TERMCAT, Centre de Terminologia.
- ↑ «Introduction to Assembly Language» (en anglès). www.swansontec.com. [Consulta: 14 maig 2017].
- ↑ Verle, Milan. «5.1 Elements of Assembly Language | Architecture and programming of 8051 MCUs» (en anglès). learn.mikroe.com. [Consulta: 14 maig 2017].
- ↑ Booth, Andrew D; Britten, Kathleen H.V.. Coding for A.R.C.. Institute for Advanced Study, Princeton, 1947 [Consulta: 25 març 2023].
- ↑ Principles of Computer Architecture (POCA) – ARCTools computadora virtual disponible para descarga y ejecución del código, acceso el 24 de agosto de 2005
- ↑ Murdocca, Miles J. y Heuring, Vincent P.:Principles of Computer Architecture (2000), Prentice Hall, ISBN 0-201-43664-7
Bibliografia
[modifica]- Robert Britton: MIPS Assembly Language Programming. Prentice Hall, 2003. ISBN 0-13-142044-5
- John Waldron: Introduction to RISC Assembly Language Programming. Addison Wesley, 1998. ISBN 0-201-39828-1
- ASM Community Book "An online book full of helpful ASM info, tutorials and code examples" by the ASM Community
- Jonathan Bartlett: Programming from the Ground Up. Bartlett Publishing, 2004. ISBN 0-9752838-4-7
Also available online as PDFArxivat 2009-02-06 a Wayback Machine. - Jeff Duntemann: Assembly Language Step-by-Step. Wiley, 2000. ISBN 0-471-37523-3
- Randall Hyde: The Art of Assembly Language. No Starch Press, 2003. ISBN 1-886411-97-2
Draft versions available online as PDF and HTML - Principios de arquitectura de computadoras - Miles J. Murdocca - Vincent P. Heuring
Vegeu també
[modifica]
