Llenguatge assemblador

De la Viquipèdia, l'enciclopèdia lliure.
Saltar a la navegació Saltar a la cerca
Nota de desambiguació.svg Desambiguació : aquí es refereix "Assemblea". Si busqueu altres significats, vegeu Assemblea (desambiguació) .
muntatge
llenguatge de programació
Motorola 6800 Assembly Language.png
Codi de muntatge del processador Motorola 6800
Data d’origen es remunta als primers ordinadors del programa memoritzat
Ús llenguatge d’ús general
Paradigmes programació genèrica
Escrivint cap
Extensions comunes .asm .s

El llenguatge assemblador (també anomenat llenguatge assemblador [1] o llenguatge assemblador [2] o simplement assemblatge ) és un llenguatge de programació molt similar al llenguatge màquina , encara que diferent d’aquest últim. Sovint es denomina erròniament " assemblador ", però aquest últim terme només identifica el programa "assemblador" que converteix el llenguatge d'ensamblatge en llenguatge màquina.

Descripció

RISC i CISC

El llenguatge d’assemblatge és l’anomenat ISA ( Instruction Set Architecture ) d’un processador. Els diferents ISA es poden dividir en dos grans grups: RISC ( Reduced Instruction Set Computer ) i CISC ( Complex Instruction Set Computer ). El primer grup sol tenir operacions senzilles i ràpides, amb una gran abundància de registres per emmagatzemar resultats intermedis. El segon proporciona al programador instruccions més complexes, que de vegades imiten les dels llenguatges de nivell superior (per exemple, copiant cadenes en processadors x86). En ambdós casos, els millors conjunts d'instruccions solen ser els anomenats ortogonals , on els diferents mètodes d'adreçament i els diferents registres es poden utilitzar indistintament en totes les instruccions. Els famosos conjunts d’instruccions ortogonals són els del Motorola 68000 (CISC) i el MIPS (RISC). L'ISA dels processadors Intel x86 originalment era molt poc ortogonal i cada vegada ha estat millor.

La distinció entre conjunts d’ instruccions RISC i CISC és una mica difusa avui en dia, perquè la majoria dels processadors de consumidors actuals són CRISP , és a dir, una barreja de tots dos. A més, alguns processadors tradueixen l'ISA original en un conjunt d'instruccions internes, per diferents motius i de diferents maneres:

  • en el cas d’ Intel Pentium 4 i AMD Athlon , es tracta d’eliminar les limitacions causades per un ara arcaic ISA compatible amb versions anteriors, i la conversió es realitza directament mitjançant maquinari dedicat que realitza la descodificació necessària;
  • en el cas dels processadors Transmeta , és capaç de "traduir" l'ISA d'altres processadors existents com si fossin propis, i la traducció es fa per una cosa conceptualment molt similar a les rutines de firmware (anomenades microcodi ) emmagatzemades en una ROM àrea obtinguda sobre el silici del microprocessador.

Abast

El muntatge té el propòsit general de permetre al programador ignorar el format binari del llenguatge de màquina. Cada codi de funcionament del llenguatge de la màquina és substituït, en el conjunt, per una seqüència de caràcters que el representa en forma mnemotècnica ; per exemple, el codi opcional de la suma es podria transcriure com a ADD i el ADD del salt com a JMP . En segon lloc, les adreces de dades i memòria manipulades pel programa es poden escriure, en conjunt, en la base numèrica més adequada en aquest moment: hexadecimal , binària , decimal , octal però també en forma simbòlica, mitjançant cadenes de text (identificadors). El programa de muntatge és, doncs, relativament més llegible que el del llenguatge de màquina, amb el qual, però, manté un isomorfisme total (o gairebé total). El programa escrit en muntatge no el pot executar directament el processador; s'ha de traduir al llenguatge de màquina (binari) corresponent, mitjançant un programa compilador anomenat assembler .

No la singularitat

A causa d'aquesta "proximitat" al maquinari, no hi ha un llenguatge de muntatge únic. Per contra, cada CPU o família de CPU té el seu propi conjunt, diferent dels altres. Per exemple, els llenguatges de muntatge per als processadors Intel x86 , Motorola 68000s i Dec Alpha són força diferents . Això vol dir que conèixer un llenguatge de muntatge determinat significa poder escriure programes només en una determinada CPU o família de CPU. Canviar a altres CPU, però, és relativament fàcil, ja que molts mecanismes són similars o completament idèntics, de manera que sovint la transició es limita a aprendre nous codis mnemotècnics, nous mètodes d’adreçament i altres peculiaritats del nou processador.

És molt menys fàcil portar un programa escrit en muntatge en màquines amb processadors diferents o amb arquitectures diferents: gairebé sempre significa haver de reescriure el programa de dalt a baix, perquè els llenguatges de muntatge depenen completament de la plataforma per a la qual eren escrit. Molts compiladors de muntatges admeten sistemes de macros que es podrien utilitzar per solucionar parcialment aquest problema, però no és una solució eficaç.

A més, el conjunt no ofereix cap " control sobre tipus " (no hi ha res vagament similar al concepte de " tipus " en la programació de baix nivell ), però deixa al programador responsable de tenir cura de cada detall de la gestió de la màquina i requereix molta disciplina i un extens treball de comentaris per evitar escriure un codi absolutament il·legible (per a altres programadors i per a ells mateixos després d'un temps).

Davant d’aquests desavantatges, el muntatge ofereix una eficiència sense igual i un control complet i absolut sobre el maquinari: els programes de muntatge són, en principi, els més petits i ràpids que es poden escriure en una màquina determinada.

L’escriptura de codi (bo) en el muntatge requereix molt de temps, és difícil i, per tant, és molt car, sobretot en perspectiva (futures modificacions): per aquest motiu, el muntatge poques vegades és l’únic llenguatge que s’utilitza en un projecte convencional, tret que tingui una mida i un abast limitats. . Generalment s’utilitza en combinació amb altres idiomes: la majoria del codi s’escriu en un llenguatge d’ alt nivell, mentre que les parts més crítiques (per raons de rendiment, precisió de temps o fiabilitat) s’escriuen en conjunt.

Aquests problemes es troben principalment en plataformes com ara ordinadors personals actuals, on l’enorme quantitativa i l’enorme ventall qualitatiu de maquinari disponible crea un problema objectiu mai resolt (i presumiblement no solucionable) a nivell d’unificació i estàndard per a aplicacions de baix nivell. . A això s’afegeix l’evolució constant cap a una estratificació cada vegada més gran de sistemes operatius comuns, caracteritzada per nombroses restriccions i virtualitzacions de perifèrics físics i canals de comunicació, que no faciliten el desenvolupament d’un programari que interactuï directament amb el maquinari subjacent. gestionar-ne les característiques.

Tot i això, podem citar dos exemples, per molt relacionats que siguin, d’inversió total d’aquest paradigma general:

  • Té molt sentit crear programes completament en conjunt destinats a maquinari arquitectònicament caracteritzat per una documentació exhaustiva, una gran predictibilitat, estabilitat i baixa variabilitat temporal del disseny: per exemple, podem esmentar els ordinadors domèstics dels anys vuitanta , com el Commodore Vic- 20 i C64 o el Sinclair ZX Spectrum .
  • També té sentit, i una forta confirmació en la pràctica dels darrers trenta anys, operar principalment o exclusivament en el muntatge al vast mercat de sistemes incrustats , per a la programació de microcontroladors i DSP , possiblement també en forma de nuclis implementats a través de ASIC , CPLD i FPGA. , Amb la finalitat de maximitzar el rendiment i el respecte per les limitacions de temps, tot minimitzant la petjada . Això es reflecteix en tots els nivells de la cadena de producció, des del disseny dels xips i el llenguatge relacionat amb l'ús de RISC tipus i fortament ortogonals NIA , la optimització (en l'espai o en el rendiment) és molt senzill. Aquest enfocament és fonamental ja que permet grans economies d'escala en projectes típics del món incrustat , caracteritzats per la capacitat d'absorbir fins i tot costos inicials elevats ( NRE, costos d'enginyeria no recurrents ), sempre que estiguin dirigits a una forta compressió de la unitat cost del producte final, també per a volums mitjans-baixos.

Per tant, la possibilitat d’utilitzar un microcontrolador amb recursos de memòria ROM i RAM molt reduïts escrivint el microprogramari completament en muntatge es fa imprescindible per minimitzar els costos, les càrregues a la placa, la susceptibilitat electromagnètica, i també augmentar la fiabilitat (més “obsoletes” tenen un avantatge insuperable) en termes de milions d’hores de proves i operació en el camp, que és, amb diferència, la "mercaderia" més valuosa per a sistemes incrustats de diverses crítiques) i l'optimització de molts altres factors.

Estructura

L’estructura d’un llistat de conjunts x86 típic per a PC s’estructura de la manera següent:

  • capçalera, en la qual podem inserir, mitjançant comentaris, el nom i la funció del programa.
  • segment de dades, en què declarem formalment les variables utilitzades pel programa (a la pràctica assignem àrees de memòria del segment que apunta des del segment de dades DS)
  • segment de pila, en el qual definim l’estructura de pila associada al programa (parlarem de la pila més endavant)
  • segment de codi, en què hi ha el codi del programa
  • tancament

Val la pena reiterar que aquesta estructura, en la seva generalitat, depèn gairebé totalment de la plataforma i també del muntador utilitzat i, per tant, no es pot universalitzar de cap manera. Diferents arquitectures, des de mainframes fins a microcontroladors, amb assembladors i ensambladors relatius, imposen estructures de fonts que de vegades són clarament diferents del simple exemple il·lustrat, relacionat amb ordinadors comuns. Per a un contraexemple trivial, en arquitectures de Harvard utilitzades per gairebé tots els microcontroladors i moltes arquitectures de supercomputació:

  • el segment de codi no es pot escriure durant el processament normal: segueix, entre altres coses, la impossibilitat absoluta de crear codi d’automorfització (auto-modificació), sinó també una forma generalment diferent de fer referència a variables (en sentit estricte, etiquetes corresponents a una o més ubicacions a la memòria de dades) i codi a la font;
  • les dades al seu torn resideixen en memòries físicament separades, de vegades també dotades de persistència entre sessions (EPROM, Flash EEPROM, memòria RAM "emmagatzemada", és a dir, equipada amb una bateria de seguretat ...), i tot això es reflecteix explícitament i de forma generalitzada a la sintaxi suportada per l'assemblador, en les directives específiques i en l'estructura real d'una font d'assemblea;
  • per últim, però no menys important: els registres com DS i SS (segment de pila) són altres peculiaritats de la plataforma x86, sovint la pila de trucades ni tan sols és accessible directament als nuclis MCU més populars.

Mostra de codi

Exemple de programa " Hello world " en el muntatge Intel x86 amb sintaxi Intel (aprofita les trucades al sistema operatiu DOS). No és compatible amb les versions UNIX GNU Assembly

 MODEL PETIT
PILA 100 H
.DATA
    HW DB " hola , món " , 13 , 10 , ' $ '
.CODIFICAR
.INICI
    MOV AX , dades @
    MOV DS , AX
    MOV DX , OFFSET HW
    MOV AH , 09 H
    INT 21 H
    MOV AX , 4 C00H
    INT 21 H
FINAL

En canvi, aquest és l'exemple del programa escrit per a la sintaxi AT&T (per a arquitectures UNIX GNU )

 Dades de la secció

	Hola:
		.ascii "hola hola món! \ n"

	hola_len:
		.llarg . - hola # longitud de la cadena en bytes

.secció .text

	.global _start

_començar:
	movl $ 4 , % eax # 4 correspon a la crida del sistema "write"
	movl $ 1 , % ebx # print a la sortida estàndard (pantalla)
	Leal hola,% ECX # Char punter al que voleu imprimir
	
	movl hello_len,% EDX # copiar el contingut de la variable. carrega la longitud de la variable

	int $ 0x80 # trucada al sistema (int seria "interrupció"); amb 0x80 s'inicia una interacció general
                                # declarat (basat en els valors carregats prèviament als registres)
				
	movl $ 1 , % eax # 1 correspon a la trucada del sistema "exit"

	xorl % ebx , % ebx #zero EBX; movl $ 0,% ebx també es pot escriure, però és menys eficient

	int 0x80 dòlars

Microinstruccions

Quan s'executa una instrucció de muntatge, el processador (d'acord amb l'arquitectura que es té en compte) realitza una sèrie d'operacions anomenades "Microinstruccions de muntatge", és a dir, operacions de maquinari que s'utilitzen per configurar els registres i operadors de la CPU perquè pugui que s'executi la instrucció.

Aquest procés es divideix, en el cas de les CPU Intel x86 i algunes altres, en 3 parts:

  • Recuperació: fase de càrrega en què s’incrementa el registre del PC i la CPU està preparada per realitzar l’operació;
  • Decodifica: es configuren els multiplexors a l'interior de la CPU i, si cal, es realitza una codificació de la instrucció (adreça indirecta, desplaçament, etc ...)
  • Execute: el moment en què realment es realitza l'operació

D’aquí l’abreviació FDE, Fetch-Decode-Execute, que s’indica als textos arquitectònics i a les fitxes tècniques.

Per posar un exemple per a l'arquitectura Intel 80x86 amb un sol BUS, en sintaxi AT&T, aquesta instrucció:

 AFEGEIX % EBX , % EAX

en què el contingut del registre EAX s'afegeix al contingut del registre EBX i el resultat es desarà a EAX, es realitzen aquestes microoperacions:

 1. PCout , SELECT [ 4 ], ADD , Zin , MARin , READ ; el PC s'incrementa per realitzar la següent operació
2. Zout , PCin , WMFC , espera que es faci la lectura de la memòria
3. MDRout , IRin , s'envia la següent instrucció en IR
4. EAXout , Vin ; el contingut d'EAX s'envia en un registre temporal
5. EBXout , SELECT [ V ], ADD , Zin ; el contingut d'EBX s'afegeix mitjançant l'ALU amb EAX
6. Zout , EAXin , END , el resultat es copia a EAX

En algunes arquitectures, aquestes fases resulten ser quatre (per exemple, als microxips PIC, a Intel 8051 i en molts nuclis similars), que també mostren la relació real entre la velocitat del rellotge o la freqüència del cristall extern (per exemple, 10 MHz) ) i nombre d'instruccions realment executades en un segon. Per als PIC (famílies de línia de base i de gamma mitjana en particular), aquesta proporció és igual a 1/4, ja que a cada cicle de rellotge el nucli realitza una sola fase Fetch-Decode-Execute-Write i, per tant, cal completar quatre cicles del rellotge extern una sola instrucció. En arquitectures de nuclis i microcontroladors de disseny més arcaics o diferents, calen encara més cicles de rellotge per a cada fase (per exemple, tres o quatre), per tant, la diferent relació entre rellotge i MIPS, que en el cas del disseny original 8051 requereix, per exemple, 12 cicles de rellotge per a cada instrucció. Finalment, cal recordar que algunes instruccions, que normalment inclouen salts incondicionals, requereixen en un nombre considerable de plataformes (tant RISC com CISC, concebudes en diverses èpoques) un nombre més gran de cicles que les altres, a causa de les operacions accessòries (no paral·lelitzables) ) requerit per l'actualització del registre IP i de les cues de prefetch internes.

C-asm

De vegades, en programacions d’alt nivell en entorns com DOS, cal realitzar algunes operacions que són molt més ràpides utilitzant instruccions de llenguatges de baix nivell (a Windows, en canvi, a causa de les proteccions de memòria, Les trucades WINAPI , L / M s’utilitzen principalment per a procediments matemàtics accelerats o per conductors ). Entre els llenguatges d’alt nivell que ho permeten hi ha C i C ++ , en què es poden inserir parts escrites en muntatge a les seves fonts que, durant la compilació, es traduiran amb un procediment conegut com a muntador en línia . Un exemple de codi escrit en C-asm (mitjançant l'assemblea Intel x86), que mostra un número determinat en binari com a entrada, és el següent exemple que utilitza la directiva stdio.h que gestiona les operacions d'entrada / sortida, la directiva iostream. h que té les mateixes funcions que l'anterior, però que garanteix la compatibilitat amb compiladors antics i finalment la directiva conio.h responsable de crear interfícies textuals.

 #include <stdio.h>
#include <iostream.h>
#include <conio.h>
int main () 
{
    int a ;

    / * Adquisició del valor numèric * /
    printf ( "Introduïu un valor entre -32768 i 32768");
    scanf ( " % d " , & a ) ;

    / * Visualització del missatge de resposta * /
    printf ( " El valor corresponent en binari és : " ) ;
    
    / * Paraula clau per delimitar seccions del codi de muntatge * /
    asm 
    { 
        / * Visualització de la cadena de bits corresponent * /
        MOV BX , WORD PTR a
        MOV CX , 00 Ah
    }

    / * Etiqueta externa * /
    Cicle: 
        asm
        {
            / * Extreure una mica * /
            MOV DL , 00 H
            RCL BX , 1 / * El valor del bit es col·loca a la bandera de transport * /
            ADC DL , ' 0 ' / * Determineu el caràcter que es mostrarà * /
            MOV AH , 02 H / * Pantalla * /
            INT 21 h
            Cicle de bucle
        } 
    retorn 0 ;
}

Per a la majoria d’aplicacions convencionals , ara es creu habitualment a la comunitat de programadors d’aplicacions que factors com les optimitzacions generades automàticament pels compiladors en llenguatges de nivell superior, l’evolució de les biblioteques que cada cop s’optimitzen (almenys en principi) i l’augment de la potència de processament de les plataformes d’ús habitual fa que sigui menys necessari que en el passat recórrer a la verticalització mitjançant conjunts en línia o mòduls de muntatge, també a favor de la portabilitat i llegibilitat del codi. Tanmateix, hi ha nombroses excepcions que contrasten totalment amb aquesta concepció generalitzada: en particular en el món dels sistemes dedicats, basats gairebé per definició en un paradigma molt diferent, tal com s’esmenta al paràgraf "No hi ha un conjunt únic", sinó també a nombrosos nínxols especialitzats als marges del corrent principal , des de sistemes CAD / CAM fins a computació numèrica, passant per diverses aplicacions científiques, fins al desenvolupament de controladors i altres programes de sistemes.

Estructures de control en el muntatge x86

El processador executa les instruccions tal com apareixen, una darrere l’altra. Tanmateix, mitjançant estructures particulars, és possible controlar el flux executiu en funció d’una determinada condició. D’aquesta manera és possible crear estructures de selecció simple o de tipus iteratiu (cicles). Les instruccions de muntatge que s’utilitzen amb aquest propòsit són principalment de dos tipus: saltar i comparar.

Els salts poden ser incondicionals o condicionats. JMP fa un salt incondicional. L’adreça de referència sol ser una etiqueta. La condició de salt sempre està dictada pels valors del registre de bandera. Les banderes més utilitzades per als salts són:

  • ZF (indicador zero) indica si la darrera instrucció va donar lloc a 0
  • SF (signe de bandera) indica si la darrera instrucció va generar un resultat de signe negatiu
  • OF (flag overflow) indica si la darrera instrucció va generar un desbordament (amb truncament del bit més significatiu del resultat)

La construcció de selecció (si, en cas contrari)

La selecció és una estructura que us permet executar un bloc d’instruccions o un altre basat en l’aparició d’una condició.

 jo mateix
     bloc d'instruccions 1
 d'una altra manera
    bloc d'instruccions 2
 bé si

en assemblatge, mitjançant la lògica dels salts, es representa de la següent manera:

 jo:
   JNcondició altrament
   bloc d'instruccions 1
   JMP end_se
 d'una altra manera:
   bloc d'instruccions 2
 final_si:

El bucle de control a la cua (fer ... mentre)

La iteració és una estructura que permet repetir diverses vegades una instrucció sota el control d’una condició.

 repetir
     instruccions
 sempre que condició 

en assemblatge, mitjançant la lògica dels salts, es representa de la següent manera:

 cicle_inici:
   instruccions
 Condició d’inici de Jcycle 

exemple:

 MOV AX, 0000h
 cicle_inici:
   INC AX
   CMP AX, 000Ah; compareu AX i el valor 0Ah (10d)
 JNE start_cycle; saltar al principi (i repetir el cicle) si és diferent 

Atès que la comprovació de la condició es realitza al final del bucle, les instruccions seqüenciades encara s’executen almenys una vegada, fins i tot si la condició ja es comprovava a l’inici. Pràcticament:

 MOV AX, 000Ah
 cicle_inici:
   INC AX
   CMP AX, 000Ah
 JNE start_cycle 

Aquest fragment de codi hauria de comprovar si AX = 10d i, si no, incrementar AX. Si és així, sortiu del cicle. Tot i això, veiem que AX ja val 10d, però aquest registre s’incrementa de totes maneres (al final valdrà 000Bh). A més, en aquest programa concret, el cicle no s’acabarà mai: AX valdrà 11, després 12, després 13 i no arribarà a ser igual a 10. Seria una bona idea, sota les condicions, evitar expressar una igualtat:

 MOV AX, 000Ah
  cicle_inici:
    INC AX
    CMP AX, 000Ah
  JB start_cycle; saltar si és més petit (en lloc de saltar si no és igual) 

D’aquesta manera hem resolt el problema del bucle infinit. No obstant això, a causa del fet que la seqüència s'executa almenys una vegada, normalment eviteu el bucle de control de cua i utilitzeu el bucle de comprovació general.

El bucle de control general (mentre)

Una estructura iterativa amb control general es pot descriure, a un nivell alt, de la següent manera:

 mentre que condició
   instruccions
 final del cicle 

Això és el mateix que el while (condició) {seqüència} de C. en el muntatge:

 cicle_inici:
   JN condició final_cicle
       seqüència
   JMP start_cycle
 final del cicle 

exemple:

 cicle_inici:
   CMP AX, 0 Ah; compareu AX amb 10d
   JNE final_cicle; omet si és diferent
       INC AX; increment AX
   JMP start_cycle
 final del cicle 

La diferència entre aquesta estructura i l’estructura de control a la cua és que si la condició és inicialment certa, la seqüència d’instruccions no s’executa ni una sola vegada.

El bucle de comptador (per a)

El cicle de comptador té una estructura d’aquest tipus:

 CONTADOR = 0
 mentre que CONTADOR <N
   seqüència
   increment CONTADOR
 final del cicle

Es pot utilitzar un bucle de comptador si volem repetir un bloc d’instruccions diverses vegades conegudes a priori. els bucles de muntatge solen disminuir:

 CONTADOR = N
 repetir
   seqüència
   disminueix CONTADOR
 fins a CONTADOR n> 0

Com a comptador, normalment fem servir el registre CX (registre de comptadors, de fet), perquè hi ha una instrucció que executa les dues darreres instruccions automàticament: la instrucció LOOP: disminueix CX i, si CX no és 0, salta a l'etiqueta especificada .

 MOV CX, 0
 cicle_inici:
   CMP CX, N
   Cicle final JGE
   seqüència
 JMP start_cycle
 final del cicle:

Gràcies a la instrucció LOOP es fa fàcil escriure un bucle de comptador en el muntatge:

 MOV CX, <N>; on N és el nombre de repeticions a realitzar
 cicle_inici:
   seqüència
 LOOP start_cycle

Cal destacar que en el primer exemple hi ha un cicle amb control al cap, mentre que en el segon amb control a la cua i que, tot i que el segon és més compacte i més ràpid d’escriure, pot generar errors, ja que ja esmentat anteriorment, si no teniu cura de com l’utilitzeu, de fet, les instruccions s’executen almenys una vegada, de manera que si no esteu segur que el nombre de repeticions mai no pugui ser zero, és menys arriscat utilitzar la primera.

Entrada / sortida mitjançant DOS INT 21h

El muntatge, especialment al món dels ordinadors, no inclou funcions d’entrada / sortida ja preparades. Per tant, el programador ha de crear les seves pròpies rutines o confiar en les creades per tercers. Als entorns DOS és suficient col·locar el codi de servei requerit a AX i utilitzar la instrucció INT 21h per trucar a la interrupció del programari relacionada, una de les característiques més peculiars de les CPU Intel x86. Entre les funcions més habituals d’entrada / sortida de teclat:

  • servei 01h ==> Adquisició d'un caràcter des del teclat amb ressò a la pantalla. Espera que es prem una tecla i retorna el codi ASCII de la tecla premuda
  • servei 02h ==> Visualització d'un personatge a la pantalla. Imprimeix el caràcter el codi ASCII del qual es troba a DL
  • servei 07h ==> Adquisició d'un caràcter del teclat sense ressò a la pantalla. Igual que el servei de 01h, però no mostra la font a la pantalla
  • servei 09h ==> Visualització d'una cadena a la pantalla. Imprimiu la cadena que apunta l’adreça de memòria continguda a DX
  • Servei 4Ch ==> Servei de retorn al sistema operatiu. Finalitza el programa.

Per tant, per adquirir un personatge (ressò al vídeo):

 MOV AH, 01h; servei 01h
 INT 21h; si AX = 0001h, el codi ASCII de la tecla premuda passa a AL

I després voler imprimir-lo:

 MOV DL, AL; Copio el codi ASCII de la clau llegit el DL
 MOV AH, 02h; servei 02h
 INT 21h; si AX = 0002h, imprimiu el caràcter de codi ASCII en D 

Com podeu veure, les operacions de captura i d'impressió fan referència als codis de caràcters ASCII. Si voleu llegir un dígit numèric com a entrada, per tornar al valor numèric només resteu el valor 30h (48 en decimal) del seu codi ASCII. De fet, 30h a ASCII correspon al caràcter "0", 31h (49 en decimal) a "1" i així successivament ...

En cas que vulgueu imprimir una cadena:

 DB cadena 13,10, "aquesta és una cadena", "$"; Assigno una variable d’un byte que anomeno cadena i en la qual deso una seqüència de caràcters (una cadena de fet)
 LEA DX, corda; Copio l'adreça de memòria que apunta a la cadena en DX
 MOV AH, 09h; servei 09h
 INT 21h; si AX = 0009h, llavors imprimeix la cadena apuntada per l'adreça de memòria continguda a DX

Muntatge X86

Assembly x86 és una família de llenguatges Assembly, que s’utilitza per crear codis objecte per als processadors Intel X86 . Com tots els llenguatges de muntatge, utilitza paraules curtes per fer instruccions de la CPU .

Nota

  1. Tanenbaum 2006 .
  2. ^ assembler language , a Treccani.it - ​​Enciclopèdies en línia , Institut de l'Enciclopèdia Italiana.

Bibliografia

Articles relacionats

Altres projectes

Enllaços externs

Control de l'autoritat Thesaurus BNCF 45031 · LCCN (EN) sh85008765 · GND (DE) 4003255-3 · BNF (FR) cb11961749m (data)
Informàtica Portal de TI : accediu a les entrades de Viquipèdia relacionades amb TI