Sintassi di mov. Un istruzione (p.es. ) non può avere sorgente m e destinazione m

Transcript

1 Sintassi di mov Gli operandi delle istruzioni possono essere di 3 specie principali: 1. dati immediati (sono parte dell istruzione, p.es. nei formati delle istruzioni sono indicati con imm 2. registri non di segmento, indicati nei formati delle istruzioni con r; 3. riferimenti a locazioni di memoria, diretti (offset) o indiretti (solo via registri specializzati come ); sono indicati con m Inoltre valgono le convenzioni: r/m indica un operando che può essere tanto r quanto m; 8 o 16 possono indicare la dimensione; p.es. r8 (r 8 bit); operandi combinati da un istruzione hanno uguale dimensione. Un istruzione (p.es. ) non può avere sorgente m e destinazione m Esempio. Formati di : r,r/m r/m,r r/m,imm A tali formati principali vanno aggiunti: r/m,rseg rseg,r/m dove rseg denota un registro di segmento. ) Introduzione all assembler x86 16/11/ /14

2 mov e accessi alla memoria L istruzione può avere una locazione, specificata da un offset, come sorgente o destinazione. P.es.: mov al,[10h] mov bx,[20h] mov [20H],ax ; al:= byte all offset 10H (nel segmento indicato da DS) ; bx:= word all indirizzo 20H ; (word all indirizzo 20H):= ax In realtà se l offset è specificato numericamente come sopra, l assemblatore richiede anche il segment override prefix (v. oltre). Per rifare la stessa operazione sulle celle n,n+1,... un programma pone n in, esegue l operazione, incrementa e ricomincia. P.es.: incremento dei byte in, : mov bx,200h mov cx,3h ; n.byte da incrementare incr_next: mov al,[bx] ; al:= (contenuto cella di indirizzo = bx) inc al ; incrementa al mov [bx],al ; memorizza il byte incrementato inc bx ; bx:= (indirizzo prossimo byte da inc.) dec cx ; aggiorna n.byte da incrementare jnz incr_next ; ricomincia, se ci sono ancora byte da incr. L accesso indiretto via può riguardare anche una word: mov ax,[bx] Sull 8086 solo i registri,,, permettono l accesso indiretto: mov ax,[cx] ; errore! Una sola non può operare su due locazioni di memoria: p.es. non è valida; invece si deve usare, p.es.: mov bl,[21h] mov [20H],bl Questo non è molto meno efficiente di! " #! (stessi cicli di bus). Introduzione all assembler x86 16/11/ /14

3 Istruzioni di salto I salti possono essere condizionati (da flags) o incondizionati. In un programma assembler, il target (obiettivo) del salto è l etichetta simbolica (terminata da $ % ) di una riga del programma: mov ax,3 sub bx,ax ; il flag Z diventa 1 se bx-ax fa 0, 0 altrimenti jz oltre ; salta a oltre se il flag Z è 1, altrimenti continua inc dx ; eseguita solo se il flag Z è 0... oltre: mov cx,dx ; eseguita se jz oltre trova il flag Z a 1 jz label salta a label se il flag Z è 1, jnz label salta se Z è 0; jmp label salta sempre. label = lettera seguita da (sequenza di lettere, cifre o _ ) l assemblatore tiene conto solo dei primi 31 caratteri della label Esempio: frammento di programma che (non alterando ax): pone in dx: 1 se ax=bx, 0 altrimenti. cs:0005 8BC8 mov cx,ax ; copia AX (per non perderlo) cs:0007 2BC3 sub ax,bx ; se ax=bx il flag Z va a 1 cs: jz make1 ; in tal caso salta a make1 cs:000b BA0000 mov dx,0 ; dx=0 perchè ax<>bx cs:000e EB04 jmp reset ; va a ristabilire l ax iniziale cs: nop ; inserita dall assemblatore cs:0011 BA0100 make1: mov dx,1 ; dx=1 perchè ax=bx cs:0014 8BC1 reset: mov ax,cx ; ristabilisce l ax iniziale In realtà i salti in binario contengono l incremento signed displ da dare a & ' perché prenda l offset della label cui saltare. P. es. ( ) * +, -. / perché (istruzione successiva) = (* +, -. ) Formati: 4 cc e short : opcode displ (1byte); salta di : ; ; < = > : near : opcode displ (2 byte); salta entro ; ; < = > > > Introduzione all assembler x86 16/11/ /14

4 Memorizza? A B C?? A : Semplici esempi mov bx,200h ; offset iniziale mov cx,101h ; n. byte su cui operare (inizialm. 200H-300H) un_altro: mov byte ptr [bx],0h inc bx dec cx jnz un_altro Pone in D E il n.occorrenze di? G A nelle H? I K A A -@ H L A A M H L A : mov bx,200h mov cx,28h mov dx,0 nextloc: mov ax,[bx] sub ax,127h ; 127 è l occorrenza da trovare jnz missing_count inc dx missing_count: inc bx ; due inc bx consecutivi inc bx ; portano bx alla prossima word dec cx jz done ; jz+jmp serve se nextloc dista>128 B jmp nextloc ; più ovvio e efficiente: jnz nextloc done: Pone in N E la somma K A numeri contenuti nelle word da O?? A : add_next: mov ax,0 mov bx,500h mov cx,28h add ax,[bx] inc bx inc bx dec cx jnz add_next Introduzione all assembler x86 16/11/ /14

5 Programmi assembler Un programma TASM è composto di segmenti, specificati da: nome-segmento segment ; ogni segmento può contenere dati e/o istruzioni... ; specificati in notazione assembler nome-segmento ends ; questi non possono occupare più di 64kB Durante l esecuzione del binario generato dal programma TASM, la porzione (<64K) generata da ciascun segmento del programma, sarà caricata in un distinto segmento di memoria (dalla base in su). Per ora vedremo programmi di 3 segmenti: dati, stack e codice: dati segment ; il nome dati non ha un significato specifico per TASM ; qui vengono specificati i dati usati dal programma dati ends pila segment stack ; pila non ha un significato specifico, ma stack sì ; qui viene riservato spazio per lo stack pila ends code segment ; il nome code non ha un significato specifico per TASM ; qui compaiono le istruzioni code ends La memoria per i dati si riserva con le pseudo-op (non generano istruzioni CPU): P Q (Define Byte) P R P P P S P T (Define Tenbytes). ; dx consecutivi riservano locazioni consecutive db 16h ; riserva 1 byte contenente 16H db? ; riserva 1 byte non inizializzato ( valore iniziale indeterminato) db 'z' ; riserva 1 byte, di valore pari al codice ASCII di z dw 1992D ; riserva 1 word contenente 1992D in binario signed ; forme concise di allocazione e inizializzazione: dw 1,10,100,1000 ; come dw 1 dw db 'l','a',' ','c','a','s','a' ; come db 'l' db 'a'... db 'la casa' ; come sopra, ma più breve db 10H dup('a') ; riserva 10H byte, ognuno pari al cod. ASCII di A db 20D dup(?) ; riserva 20 byte non inizializzati Introduzione all assembler x86 16/11/ /14

6 Indirizzi simbolici in assembler In assembler non si usano di solito indirizzi espliciti. P.es: mov ax,[100] ; se manca ds:, TASM intende come mov ax,100 (warning) (ma usiamo U V W X Y Z [ \ ] ] ^ come forma simbolica dell istruzione _ \ ] ] ] \ ) Invece, si attribuiscono ai dati identificatori simbolici o nomi; nelle istruzioni il nome prende il posto dell indirizzo di un dato. Assembler Simbolico Binario yes_msg db 'Y' yes_msg prende la loc mov al,yes_msg mov al,[0013] 0005 A01300 mov yes_msg, S mov byte ptr [0013], C TASM traduce id offset nel codice binario contando i byte occupati da dati e istruzioni precedenti id. Nel nome qualificato (completo) di un dato figura anche il segmento: data segment x dw 1234H data ends... mov data:x,0 ; equivale a mov x,0 Ma ` deve essere unico: un solo dato in un solo segmento. In una define multipla di dati, il nome individua l offset del 1 dato: dec31_msg db 'buon anno' mov al,dec31_msg ; pone 'b' in al Con l operatore a b b c d e l offset di un nome si può usare come dato: x dw 1234 ; sia 8a90 l'offset di x mov ax,x ; mov ax,[8a90] (pone 1234 in ax) mov ax,offset x ; mov ax,8a90 Introduzione all assembler x86 16/11/ /14

7 Istruzioni in forma simbolica vs. assembler Come visto, ogni istruzione x86 può essere trascritta in tre forme: binaria simbolica: - opcode e operandi registri in formato mnemonico, - operandi offset e n.segmento in formato numerico; p.es.: mov [0120H], ax jmp +2 assembler: come simbolica, ma offset e n.segmento compaiono come identificatori: mov x,ax ; l assembler tradurrà p.es. in mov [0120H],ax jmp out ; l assembler tradurrà p.es. in jmp +2 Differenza tra istruzione simbolica (f g h +i ) e assembler (f g h j k l ): la istruzione simbolica, anche da sola, individua univocamente la corrispondente binaria (f g h m i n o p i ) la istruzione assembler deve stare in un programma completo (per calcolare gli offset) per essere tradotta in binario. Introduzione all assembler x86 16/11/ /14

8 Assemblaggio di identificatori TASM assembla senza altra informazione istruzioni con identificatori, purché dotate di segment override prefix. P.es.: Ma il codice data1 segment F000*(??) z db 0f000h dup(?) 3 F A x1 dw 978ah 4 F002 data1 ends data2 segment ABCD x2 dw 0ABCDH data2 ends code segment B 1E F000r mov bx,ds:x : 8B 1E 0000r mov bx,es:x code ends code segment B 1E F000r mov bx,x : 8B 1E 0000r mov bx,es:x code ends causa l errore (riga 9): can t address with currently assumed segment registers Problemi: 1. TASM sospetta (correttamente) che q r non punti segmento di s t 2. basta però il prefisso q r u per ingannarlo! Soluzioni: 1. pseudo-op v r r w x y 2. chi usa q r come prefisso dovrebbe ricordarsi di dare a q r un valore opportuno Introduzione all assembler x86 16/11/ /14

9 Pseudo-op assume e gestione dei segment register Motivazione della pseudo-op z { { } ~ : un istruzione sul dato x dichiarato nel segmento N ha senso solo se un registro di segmento r{ punta a N (contiene l indirizzo di N) per assicurare ciò a TASM, il programmatore deve (pena l errore can t address with currently assumed segment registers): 1. dare all istruzione il segment override prefix r{ (v. p. 7), o 2. dichiarare z { { } ~ r{ N = assumi (supponi) che r{ punta a N NB: (1) o (2) non mettono automaticamente in r{ l indirizzo di N, ma dovrebbero servire a ricordare al programmatore di farlo! Esempi data1 segment z db 0f000h dup(?) x1 dw 978ah ; offset di x1: f000 data1 ends data2 segment x2 dw 0ABCDH ; offset di x2: 0000 data2 ends assume ds:data1 ; caso (1); se mancasse assume ds:data1 mov bx,x1 ; qui TASM segnalerebbe l errore can t address... mov bx,es:x2 ; caso (2); se mancasse es: TASM segnalerebbe l errore Ciò non dà errori TASM, ma è scorretto: va completato come ricordano ƒ e mov ax,data1 ; dopo TASM, TLINK traduce data1 in indirizzo di segmento mov ds,ax ; data1 ax ds perché non l istruzione mov ds,dato assume ds:data1 ; assicura a TASM ds=data1 e ricorda di farlo davvero mov bx,x1 ; TASM assembla in 8b1e00f0=mov bx,[f000] mov ax,data2 ; che data2 va posto in es... mov es,ax ; viene ricordato dal prefisso es: nel prossimo rigo mov bx,es:x2 ; TASM assembla in 268b1e0000=mov bx,es:[0] NB: l override prefix ds: può servire per (2) sopra, ma non viene assemblato (inutile): assume ds:nothing ; annulla ogni assume riguardo a ds mov al,ds:z ; ds: serve per (2), ma TASM a00000=mov al,[0] Introduzione all assembler x86 16/11/ /14

10 Schema di programma assembler data data segment... ; dichiarazioni dei dati ends pila segment stack dw 100H dup(?) ; o altra quantità di memoria richiesta pila ends code segment assume ds:data,ss:pila,cs:code start: mov ax,data ; carica (via ax) l indirizzo del segmento data mov ds,ax ; in ds, reg. di segmento assunto per data... ; istruzioni del programma mov ah,4ch ; pone in ah il numero del servizio DOS che, int 21h ; invocato con int 21 riporterà al DOS code ends end start ; definisce l entry point (1 a istruzione da eseguire) Osservazioni la direttiva ˆ indirizzo-simbolico definisce indirizzo-simbolico come entry point e contrassegna la fine del programma (ciò che segue nel file contenente il programma viene ignorato) perché il programma sia eseguibile, deve avere un entry point i nomi dei Š Œ possono fare da operandi per le istruzioni; nell eseguibile saranno sostituiti dagli indirizzi dei segmenti di memoria scelti per ciascun Š Œ del programma l indirizzo di ˆ Œ va caricato in Ž esplicitamente (vedi start:) quando il programma assemblato viene eseguito, il DOS carica automaticamente in e gli indirizzi dei segmenti ˆ e ; i valori finali di e devono riportare il sistema sotto il controllo del DOS: ciò si ottiene con: š e Œ œ ž. Introduzione all assembler x86 16/11/ /14

11 Generazione di un Ÿ Ÿ da un programma assembler Se il programma assembler risiede in un solo file (sorgente) : 1. assemblaggio in un file oggetto ( ) con l assemblatore TASM; p.es. ª «o ( ª «) genera ª «2. linking del file oggetto in un file eseguibile, con il linker TLINK; p.es. ª «(o ª «) genera ª «± ² ±. Un programma complesso è in genere suddiviso in più file ; ciascuno può definire segmenti distinti da quelli degli altri e fare riferimento a dati o etichette esterni (definiti in altri file). TASM assembla ogni in un senza consultare gli altri ; ciò fa risparmiare tempo durante lo sviluppo di un programma. Quindi TLINK non può solo concatenare gli in ± ² ± ; deve anche: risolvere i riferimenti esterni scegliere un segmento di memoria per ogni ± ± ± ³ Esempio. Mappa del codice generato da TLINK Start Stop Length Name NB: indirizzi Start/Stop a 20 bit 00000H 00001H 00002H DATA dati (2 byte) nel segmento H 0002FH 00020H PILA pila (32 byte) nel segmento H 00038H 00009H CODE istruzioni (9 byte) nel segmento 0003 Program entry point at 0003:0000 NB: i segmenti di memoria di 64K scelti si sovrappongono, ma non le loro parti veramente occupate. Il DOS, poi, nel caricare il file µ, trasla gli indirizzi di segmento scelti da TLINK (marcati come tali nel file) in memoria non occupata; p. es. nel caso sopra,, potrebbero venire caricati come ¹ º º, ¹ º», ¹ º ¹ Inoltre il DOS pone in ¼ ½ il segmento dell entry point, e in ½ ½ quello marcato ½ ¾ ¼ À nel sorgente, ma a fissare Á ½ correttamente deve provvedere il programma (v. p.10). Introduzione all assembler x86 16/11/ /14

12 Accesso a indirizzi specifici Anche se TLINK/DOS scelgono dove caricare il programma, il programmatore assembler può accedere a qualsiasi segmento S: mov ax,9ff0h mov ds,ax mov [10],bx ; da qui gli offset saranno nel segmento 9ff0 ; 9ff0:[10] := bx Ma il programmatore deve sapere cosa fa; l esempio ha senso se il segmento Â Ã Ã Ä è libero, oppure, p.es., si vogliono modificare strutture dati DOS situate in Â Ã Ã Ä Å Æ Ç Ä È Introduzione all assembler x86 16/11/ /14

13 Ø Ù Ô Servizi e funzioni DOS Il DOS fornisce servizi software a programmi che li invocano: caricando i registri con valori opportuni eseguendo l'istruzione É Ê Ë Ì Í Î Ï completato il servizio l esecuzione riprende subito dopo la É Ê Ë Il servizio è individuato dal byte Í Î e dal contenuto di alcuni registri Funzioni: servizi richiesti con Ð Ñ Ï ; Ò Ó contiene il n. della funzione. Es.: Õ Ö Õ Ö Ú Û Ü Ý Õ Þ ß Ú Û Ü Ý Õ Þ à á ß â ã â ä N. funzione Descrizione Descrizione estesa Output su Scrive il carattere il cui ASCII è in schermo Output su seriale Stampa Invia alla stampante Output stringa Scrive la sequenza di caratteri nei byte,... finché trova (non scritto) Ritorno a DOS Termina il programma chiamante e torna a DOS Esempi (output): dec31_msg db 'buon anno$'... mov dl,'e' mov ah,2 int 21H ; scrive 'e' sub dl,20h int 21H ; scrive 'E' (NB: ASCII('E') = ASCII('e')-20H) mov dl,0dh int 21H ; scrive un CR (Carriage Return) mov dl,0ah int 21H ; scrive LF (Line Feed): per andare a capo servono CR e LF mov dx,offset dec31_msg ; NB: dec31_msg deve essere nel segm. Ú Û mov ah,9 int 21H Introduzione all assembler x86 16/11/ /14

14 è é ö å å å Funzioni DOS: input æ ç æ ê ë ì í î ï ð ñ ò ó ê ë ì í î ï ô ð ê ë ì í î ï ô õ ð ò ó ê ë ì í î ï ô õ ô æ ç ø ò å ù ú ù è ù é ë û ü ý þ ÿ þ ý æ ç þ õ N. funzione Descrizione Descrizione estesa input da attende la pressione di un tasto, ne pone l'ascii in e ne tastiera causa l'eco sullo schermo; può essere interrotto con CTRL-BREAK input come ma senza echo e non si può interrompere input come ma si può interrompere con CTRL BREAK Input stringa se N, accetta k (<N) caratteri + e pone k in, il 1 car. in,..., in kð stato tastiera se un carattere di input è disponibile, pone a se no a clear input Svuota il buffer di input e esegue la funzione tra da (è come un altro ) Esempi: mov ah,1 inkey: int 21H ; leggi un carattere sub al,'x' jnz inkey ; termina se si legge una x msg db 'hai scritto:',0dh,0ah,'$' inbuf db 4 dup(?),0dh,0ah,'$' mov cx,4 ; n. caratteri da leggere mov bx,offset inbuf ; leggeremo in inbuf mov ah,7 inkey1: int 21H ; legge senza eco un carattere in al mov [bx],al ; copialo dentro inbuf inc bx dec cx jnz inkey1 ; ricomincia (esci dopo aver letto 4 caratteri) mov ah,9 mov dx,offset msg int 21H ; scrivi msg mov dx,offset inbuf ; scrivi i caratteri letti int 21H inloop: mov ah,0bh int 21H sub al,0ffh jnz inloop ; esce appena si preme un tasto Introduzione all assembler x86 16/11/ /14