Esercizi ASM CeTeM (pdf - 235 KB)

CONSORZIO NETTUNO

POLITECNICO DI

TORINO

________________________________________

DIPLOMI UNIVERSITARI TELEDIDATTICI

POLI DI TORINO ED ALESSANDRIA

CALCOLATORI ELETTRONICI II

__________________________________________

Anno Accademico 1999/00

Calcolatori Elettronici II

1 Raccolta Esercizi e note

© Politecnico di Torino Pagina 2 di 80 Data ultima revisione 27/03/01 Autori: G. Squillero, M. Violante

Politecnico di Torino CeTeM

Questa raccolta di esercizi e note, prodotta ad uso interno, è stata utilizzata per i tutorati del Corso di Calcolatori Elettronici II del Corso di Diploma Universitario Teledidattici in Ingegneria Informatica e Automatica, Anno Accademico 1999/00; ne è vietata la riproduzione e qualsiasi forma di commercializzazione. Si ringraziano i Prof.ri Laura Farinetti ed Enrico Macii per aver fornito il materiale.





SOMMARIO

ESERCITAZIONE 1 - Architettura del processore 8086

pag. 4

ESERCITAZIONE 2 - Gestione della memoria e registri interni del processore 8086

pag. 8

ESERCITAZIONE 3 - Linguaggio Assembler 8086: codice sorgente, codice macchina, assemblatore

pag. 11

ESERCITAZIONE 4 - Struttura di un programma Assembler, DB, DW, DD, MOV, ADD e SUB

pag. 12

ESERCITAZIONE 5 - Le istruzioni MOV, ADD e SUB

pag. 15

ESERCITAZIONE 6 - Salto condizionato e incondizionato, INC, DEC, CMP, XCHG

pag. 17

ESERCITAZIONE 7 - Salto condizionato e incondizionato, CMP, DUP

pag. 21

ESERCITAZIONE 8 - Modi di indirizzamento, input/output dei caratteri

pag. 26

ESERCITAZIONE 9 - Modi di indirizzamento, input/output dei caratteri

pag. 29

ESERCITAZIONE 10 -Le istruzioni MUL, IMUL e CBW

pag. 32

ESERCITAZIONE 11 -Le istruzioni DIV, IDIVe LEA; stampa di stringhe

pag. 37

ESERCITAZIONE 12 -Le istruzioni logiche, di scorrimento e di rotazione

pag. 41

ESERCITAZIONE 13 - Le procedure

pag. 46

ESERCITAZIONE 14 - Prova di autovalutazione

pag. 50

ESERCITAZIONE 15 - Correzione della prova di autovalutazione

pag. 51

ESERCIZI RISOLTI pag. 54





ESERCITAZIONE 1

Argomenti trattati: • Architettura del processore 8086. • Caratteristiche generali. • Configurazione interna. • Descrizione funzionale. • Pipeline. Architettura di una CPU:

DR

AR

PC IR

AC

ALU

Control





Il microprocessore INTEL 8086:

GND

AD14

AD13

AD12

AD11

AD10

AD9

AD8

AD7

AD6

AD5

AD4

AD3

AD2

AD1

AD0

NMI

INTR

CLK

GND

VCC

AD15

A16/S3

A17/S4

A18/S5

A19/S6

BHE/S7

MN/MX

RD

RQ/GTO (HOLD)

RQ/GT1 (HLDA)

LOCK (WR)

S2 (M/IO)

S1 (DT/R)

SO (DEN)

QSO (ALE)

QS1 (INTA)

TEST

READY

RESET

modo max

modo min

INTEL

8086

Connessione ai bus:

8086

Bus di Dati

Bus di Indirizzi

Bus di Controllo





Configurazione interna del microprocessore INTEL 8086:

Ground

Logica diControllo

Instruction Queue

SPBPSIDIIP

Registri puntatori

AHBHCHDH

ALBLCLDL

Registri di segmento

Registri di datoAddress/Data

20 pin

Control

16 pin

+5V

Clock

2CSSSDSES

PSW

Parola di Stato

UnitàAritmetico

Logica(ALU)

Instruction queue:

8086

ExecutionUnit(EU)

BUS di SISTEMA

Bus InterfaceUnit(BIU)

Instruction Queue(IQ)

Memoria Periferiche

Dati





Pipeline:

Fi-1 Fi

Ei-1

Fi+1

Ei Ei+1

Fi-1 Ei-1 Fi Ei Fi+1 E1+1

(a) processamento sequenziale

(b) processamento in pipeline

BIU

EU





ESERCITAZIONE 2

Argomenti trattati: • Gestione della memoria. • Gestione degli indirizzi. • Lo stack. • I registri. Segmentazione della memoria:

FFFFF16

8086

IP

CSDSSSES

AXBX

PSW

SIDI

DX

AH ALBH BL

DH DL

SPBP

CH CL CX

Memoria

Segmento diCodice

(64 Kbyte)

Segmento diDato

(64 Kbyte)

Segmento diStack

(64 Kbyte)

Segmento Extradi Dato

(64 Kbyte)

0000016





Calcolo degli indirizzi fisici:

4

16

12

16

Effective Address Offset

Indirizzo di base del segmento

+

Indirizzo Fisico

Registro di Segmento

Lo stack:

01 05

00 0E

SS

SP

34 0045 0913 B400 A0

0105E

0105C

0105A

01058

01056

01054

01052

01050

01062

01064

01066

01068 FF FF

end of the stack

top of the stack

bottom of the stack





Operazioni sullo stack:

01 05

00 10

SS

SP

0105E

0105C

0105A

01058

01056

01054

01052

01050

Stack vuoto

01 05

00 0E

13 41

PUSH AX

13 41AX

01 05

00 0C

13 4145 F0

PUSH AX

45 F0AX

01 05

00 0E

13 41

POP BX

45 F0BX

Il registro di stato:

Processor Status Word

Carry (riporto)

OF DF IF TF SF ZF AF PF CF

15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

Overflow (tracimazione)

Direction (direzione)Enable Interrupt

(abilitazione interruzioni)Trap (trappola)

Sign (segno)

ZeroAuxiliary Carry

(riporto ausiliario)Parity (parità)





ESERCITAZIONE 3

Argomenti trattati: • Il linguaggio Assembler 8086. • Codice sorgente. • Codice macchina. • L’assemblatore. • Il linker. • Il loader. • Uso dell’assemblatore Microsoft MASM 6.0. Ambiente di sviluppo di programmi Assembler 8086:

.lib

CodiceAssembler

ASSEMBLATORE

ModuloOggetto

.asm

.obj

CodiceC

.c

ModuloOggetto .obj Librerie

COMPILATOREC

Programmaeseguibile .exe

LINKER





ESERCITAZIONE 4

Argomenti trattati: • Struttura di un programma Assembler. • Le direttive DB, DW e DD. • L’istruzione MOV. • Le istruzioni ADD e SUB.

Esercizi proposti:

Esercizio 1: Scrivere un programma Assembler che esegua la somma di due numeri (su 8 bit) che si trovano nelle locazioni di memoria OP2 e OP2, e ponga il risultato nella locazione RIS.

Soluzione: ; programma che esegue la somma ; fra due numeri su 8 bit .MODEL small .STACK .DATA OP1 DB 11 ; primo operando OP2 DB 7 ; secondo operando RIS DB ? ; risultato .CODE .STARTUP MOV AL, OP1 ; sposto il primo operando nel registro AL ADD AL, OP2 ; eseguo la somma MOV RIS, AL ; memorizzo il risultato in RIS .EXIT END

Esercizio 2: Scrivere un programma Assembler che esegua la differenza fra due numeri (su 16 bit) che si trovano nelle locazioni di memoria OP2 e OP2, e ponga il risultato nella locazione RIS.





Soluzione: ; programma che esegue la sottrazione ; fra due numeri su 16 bit .MODEL small .STACK .DATA OP1 DW 30H ; primo operando OP2 DW 12H ; secondo operando RIS DW ? ; risultato .CODE .STARTUP MOV AX, OP1 ; sposto il primo operando nel registro AX SUB AX, OP2 ; eseguo la sottrazione MOV RIS, AX ; memorizzo il risultato in RIS .EXIT END

Esercizio 3: Scrivere un programma Assembler che calcoli l’espressione W = X-2Y+3Z. Si supponga che X, Y, Z e W siano numeri su 16 bit.

Soluzione: ; programma che calcola W = X-2Y+3Z .MODEL small .STACK .DATA X DW 100 Y DW 45 Z DW 15 W DW ? .CODE .STARTUP MOV AX, X ; AX = X SUB AX, Y ; AX = X-Y SUB AX, Y ; AX = X-2Y ADD AX, Z ; AX = X-2Y+Z ADD AX, Z ; AX = X-2Y+2Z ADD AX, Z ; AX = X-2Y+3Z





MOV W, AX ; memorizzo il risultato in W .EXIT END





ESERCITAZIONE 5

Argomenti trattati: • L’istruzione MOV. • Le istruzioni ADD e SUB.

Esercizi proposti:

Esercizio 4: Scrivere un programma Assembler che calcoli l’espressione W = W = 3(X+2Y)-3Z. Si supponga che X, Y, Z e W siano numeri su 16 bit.

Soluzione: ; programma che calcola W = 3(X+2Y)-3Z .MODEL small .STACK .DATA X DW 50 Y DW 15 Z DW 20 W DW ? .CODE .STARTUP MOV AX, X ; AX = X MOV BX, Y ; BX = Y ADD BX, Y ; BX = 2Y ADD AX, BX ; AX = X+2Y MOV BX, AX ; BX = X+2Y ADD AX, BX ; AX = 2(X+2Y) ADD AX, BX ; AX = 3(X+2Y) SUB AX, Z ; AX = 2(X+2Y)-Z SUB AX, Z ; AX = 2(X+2Y)-2Z SUB AX, Z ; AX = 2(X+2Y)-3Z MOV W, AX ; memorizzo il risultato in W .EXIT END





Esercizio 5: Scrivere un programma Assembler che sommi i valori degli elementi del vettore VET, e ponga il risultato nella locazione di memoria SOMMA. Si supponga che gli elementi del vettore siano numeri su 16 bit.

Soluzione (prima versione): ; programma che somma gli elementi di un vettore ; prima versione .MODEL small .STACK .DATA VET DW 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 SOMMA DW ? .CODE .STARTUP MOV AX, 0 ; inizializzo AX ADD AX, VET ; sommo il primo elemento del vettore ADD AX, VET+2 ; sommo il secondo elemento (sono word!) ADD AX, VET+4 ADD AX, VET+6 ADD AX, VET+8 ADD AX, VET+10 ADD AX, VET+12 ADD AX, VET+14 ADD AX, VET+16 ADD AX, VET+18 MOV SOMMA, AX ; memorizzo il risultato in SOMMA .EXIT END





ESERCITAZIONE 6

Argomenti trattati: • Le istruzioni di salto condizionato e incondizionato. • Le istruzioni INC e DEC. • L’istruzione CMP. • L’istruzione XCHG.

Esercizi proposti:


Soluzione (seconda versione): ; programma che somma gli elementi di un vettore ; seconda versione DIM EQU 10 .MODEL small .STACK .DATA VET DW 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 SOMMA DW ? .CODE .STARTUP MOV AX, 0 ; inizializzo AX MOV CX, DIM ; carico in CX la dimensione del vettore MOV DI, 0 ; azzero il registro DI sum: ADD AX, VET[DI] ; sommo l'elemento corrispondente a VET+DI ADD DI, 2 ; passo all'elemento successivo (sono word!) DEC CX ; decremento il contatore CMP CX, 0 ; il contatore e' a zero? JNZ sum ; se e' a zero termino, se no sommo l'elemento ; successivo MOV SOMMA, AX ; memorizzo il risultato in SOMMA .EXIT END






Soluzione (terza versione): ; programma che somma gli elementi di un vettore ; terza versione DIM EQU 10 .MODEL small .STACK .DATA VET DW 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 SOMMA DW ? .CODE .STARTUP MOV AX, 0 ; inizializzo AX MOV CX, DIM ; carico in CX la dimensione del vettore MOV DI, 0 ; azzero il registro DI sum: ADD AX, VET[DI] ; sommo l'elemento corrispondente a VET+DI ADD DI, 2 ; passo all'elemento successivo (sono word!) LOOP sum ; se il contatoree' a zero termino, se no sommo ; l'elemento successivo MOV SOMMA, AX ; memorizzo il risultato in SOMMA .EXIT END

Esercizio 8: Scrivere un programma Assembler che inverta gli elementi del vettore VET. Si supponga che gli elementi del vettore siano numeri su 16 bit.

Soluzione (prima versione): ; programma che inverte il contenuto di un vettore ; prima versione DIM EQU 10 .MODEL small .STACK





.DATA VET DW 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 .CODE .STARTUP MOV SI, 0 ; primo elemento in SI MOV DI, 2*DIM-2 ; ultimo elemento in DI (sono word!) MOV CX, DIM/2 ; numero di scambi in CX scambia: ; scambio gli elementi puntati da SI e DI MOV AX, VET[SI] MOV BX, VET[DI] MOV VET[DI], AX MOV VET[SI], BX ADD SI, 2 ; aggiorno SI SUB DI, 2 ; aggiorno DI LOOP scambia ; se il contatore e' a zero termino .EXIT END


Soluzione (seconda versione): ; programma che inverte il contenuto di un vettore ; seconda versione DIM EQU 10 .MODEL small .STACK .DATA VET DW 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 .CODE .STARTUP MOV SI, 0 ; primo elemento in SI MOV DI, DIM ADD DI, DIM SUB DI, 2 ; ultimo elemento in DI (sono word!) MOV CX, DIM/2 ; numero di scambi in CX scambia: ; scambio gli elementi puntati da SI e DI





MOV AX, VET[SI] MOV BX, VET[DI] MOV VET[DI], AX MOV VET[SI], BX ADD SI, 2 ; aggiorno SI SUB DI, 2 ; aggiorno DI LOOP scambia ; se il contatore e' a zero termino .EXIT END


Soluzione (terza versione): ; programma che inverte il contenuto di un vettore ; terza versione DIM EQU 10 .MODEL small .STACK .DATA VET DW 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 .CODE .STARTUP MOV SI, 0 ; primo elemento in SI MOV DI, DIM ADD DI, DIM SUB DI, 2 ; ultimo elemento in DI (sono word!) MOV CX, DIM/2 ; numero di scambi in CX scambia: ; scambio gli elementi puntati da SI e DI MOV AX, VET[SI] XCHG AX, VET[DI] MOV VET[SI], AX ADD SI, 2 ; aggiorno SI SUB DI, 2 aggiorno DI LOOP scambia ; se il contatore e' a zero termino .EXIT END





ESERCITAZIONE 7

Argomenti trattati: • Le istruzioni di salto condizionato e incondizionato. • L’istruzione CMP. • La direttiva DUP.

Esercizi proposti:

Esercizio 11: Scrivere un programma Assembler che calcoli l’elemento massimo all’interno del vettore VET. Si supponga che gli elementi del vettore siano numeri positivi su 16 bit.

Soluzione: ; programma che calcola il massimo all'interno di un vettore ; di numeri positivi su 16 bit DIM EQU 10 .MODEL small .STACK .DATA VET DW 7, 3, 0, 11, 4, 7, 20, 3, 5, 10 MAX DW ? .CODE .STARTUP MOV AX, 0 ; inizializzo AX, che conterra' il massimo ; provvisorio MOV CX, DIM ; carico in CX la dimensione del vettore MOV SI, 0 ; SI punta al primo elemento del vettore ciclo: CMP AX, VET[SI] ; confronto il massimo provvisorio con ciascun ; elemento JA scan ; se AX > VET[SI] salto a scan MOV AX, VET[SI] ; aggiorno il massimo scan: ADD SI, 2 ; considero l'elemento successivo LOOP ciclo MOV MAX, AX ; memorizzo il massimo in MAX .EXIT END





Esercizio 12: Scrivere un programma Assembler che calcoli l’elemento minimo all’interno del vettore VET. Si supponga che gli elementi del vettore siano numeri positivi su 8 bit.

Soluzione: ; programma che calcola il minimo all'interno di un vettore ; di numeri positivi su 8 bit DIM EQU 10 .MODEL small .STACK .DATA VET DB 30, 45, 16, 7, 21, 20, 5, 3, 11, 15 MIN DB ? .CODE .STARTUP MOV AL, 0FFH ; inizializzo AL, che conterra' il minimo ; provvisorio MOV CX, DIM ; carico in CX la dimensione del vettore MOV SI, 0 ; SI punta al primo elemento del vettore ciclo: CMP AL, VET[SI] ; confronto il minimo provvisorio con ciascun ; elemento JB scan ; se AL < VET[SI] salto a scan MOV AL, VET[SI] ; aggiorno il minimo scan: INC SI ; considero l'elemento successivo LOOP ciclo MOV MIN, AL ; memorizzo il minimo in MIN .EXIT END

Esercizio 13: Scrivere un programma Assembler che azzeri tutti gli elementi negativi all’interno del vettore VET. Si supponga che gli elementi del vettore siano numeri interi su 16 bit.

Soluzione: ; programma che azzera tutti i numeri negativi all'interno di ; un vettore DIM EQU 10





.MODEL small .STACK .DATA VET DW 15, -12, -21, 0, -3, 7, 10, -11, -1, -5 .CODE .STARTUP MOV CX, DIM ; carico in CX la dimensione del vettore MOV SI, 0 ; SI punta al primo elemento del vettore ciclo: CMP VET[SI], 0 ; confronto ciascun elemento con zero JNL scan ; se VET[SI] >= 0 salto a scan MOV VET[SI], 0 ; azzero l'elemento scan: ADD SI, 2 ; considero l'elemento successivo LOOP ciclo .EXIT END

Esercizio 14: Scrivere un programma Assembler che sostituisca tutti gli elementi negativi all’interno del vettore VET con il corrispondente numero positivo. Si supponga che gli elementi del vettore siano numeri interi su 16 bit.

Soluzione: ; programma che sostituisce tutti i numeri negativi all'interno di ; un vettore con il corrispondente numero positivo DIM EQU 10 .MODEL small .STACK .DATA VET DW 15, -12, -21, 0, -3, 7, 10, -11, -1, -5 .STARTUP MOV CX, DIM ; carico in CX la dimensione del vettore MOV SI, 0 ; SI punta al primo elemento del vettore ciclo: CMP VET[SI], 0 ; confronto ciascun elemento con zero JNL scan ; se VET[SI] >= 0 salto a scan MOV AX, 0 SUB AX, VET[SI] MOV VET[SI], AX ; sostituisco con il corrispondende numero positivo scan: ADD SI, 2 ; considero l'elemento successivo





LOOP ciclo .EXIT END

Esercizio 15: Scrivere un programma Assembler che calcoli i primi 20 numeri della serie di Fibonacci. Si ricordi che: Ni = Ni-1 + Ni-2, N0 = 1, N1 = 1.

Soluzione (prima versione): ; programma che calcola i primi 20 numeri della serie di ; Fibonacci ; prima versione NUM EQU 20 .MODEL small .STACK .DATA FIB DW NUM DUP (?) .CODE .STARTUP MOV DI, 0 ; DI punta al primo elemento del vettore MOV FIB[DI], 1 ; primo numero della serie ADD DI, 2 MOV FIB[DI], 1 ; secondo numero della serie ADD DI, 2 MOV CX, NUM-2 ; CX tiene conto di quanti numeri devono ; ancora essere calcolati ciclo: MOV AX, FIB[DI-4] ADD AX, FIB[DI-2] ; a partire dal terzo ogni numero e' MOV FIB[DI], AX ; calcolato come somma dei due precedenti ADD DI, 2 ; aggiorno DI LOOP ciclo .EXIT END





Esercizio 16: Scrivere un programma Assembler che calcoli i primi 20 numeri della serie di Fibonacci. Si ricordi che: Ni = Ni-1 + Ni-2, N0 = 1, N1 = 1.

Soluzione (seconda versione): ; programma che calcola i primi 20 numeri della serie di ; Fibonacci ; seconda versione NUM EQU 20 .MODEL small .STACK .DATA FIB DW NUM DUP (?) .CODE .STARTUP MOV DI, 0 ; DI punta al primo elemento del vettore MOV FIB[DI], 1 ; primo numero della serie ADD DI, 2 MOV FIB[DI], 1 ; secondo numero della serie ADD DI, 2 MOV CX, NUM-2 ; CX tiene conto di quanti numeri devono ; ancora essere calcolati MOV AX, FIB[0] ciclo: ADD AX, FIB[DI-4] ; a partire dal terzo ogni numero e' MOV FIB[DI], AX ; calcolato come somma dei due precedenti ADD DI, 2 ; aggiorno DI LOOP ciclo .EXIT END





ESERCITAZIONE 8

Argomenti trattati: • I modi di indirizzamento: register, immediate, direct, register indirect, direct indexed. • L’input/output dei caratteri con INT21H.

Esercizi proposti:

Esercizio 17: Scrivere un programma Assembler che legga da tastiera un carattere, lo sostituisca con un asterisco (*) se non è alfanumerico, e lo stampi su video.

Soluzione: ; programma che legge da tastiera un carattere, ; lo sostituisce con un * se non è alfanumerico ; e lo stampa su video ; prima versione: non va a capo .STACK .DATA .CODE .STARTUP MOV AH, 1 ; preparo AH per la lettura INT 21H ; leggo un carattere e lo metto in AL MOV DL, AL ; pongo il carattere in DL, pronto per la stampa CMP DL, '0' ; se DL < '0' JB star ; lo sostituisco con '*' CMP DL, '9' ; se DL <= '9' JBE nostar ; è una cifra CMP DL, 'A' ; se DL < 'A' JB star ; lo sostituisco con '*' CMP DL, 'Z' ; se DL <= 'Z' JBE nostar ; è una lettera maiuscola CMP DL, 'a' ; se DL < 'a' JB star ; lo sostituisco con '*' CMP DL, 'z' ; se DL <= 'z' JBE nostar ; è una lettera minuscola star: MOV DL, '*' ; DL > 'z' -> lo sostituisco con '*'





nostar: MOV AH, 2 ; preparo AH per la stampa INT 21H ; stampo il carattere .EXIT END

Esercizio 18: Scrivere un programma Assembler che legga da tastiera un carattere, lo sostituisca con un asterisco (*) se non è alfanumerico, e lo stampi su video dopo essere andato a capo.

Soluzione: ; programma che legge da tastiera un carattere, ; lo sostituisce con un * se non è alfanumerico ; e lo stampa su video ; seconda versione: va a capo LF EQU 10 CR EQU 13 .MODEL SMALL .STACK .DATA .CODE .STARTUP MOV AH, 1 ; preparo AH per la lettura INT 21H ; leggo un carattere e lo metto in AL MOV DH, AL ; metto il carattere in DH CMP DH, '0' ; se DH < '0' JB star ; lo sostituisco con '*' CMP DH, '9' ; se DH <= '9' JBE nostar ; è una cifra CMP DH, 'A' ; se DH < 'A' JB star ; lo sostituisco con '*' CMP DH, 'Z' ; se DH <= 'Z' JBE nostar ; è una lettera maiuscola CMP DH, 'a' ; se DH < 'a' JB star ; lo sostituisco con '*' CMP DH, 'z' ; se DH <= 'z' JBE nostar ; è una lettera minuscola star: MOV DH, '*' ; sostituisco il carattere con '*' nostar: MOV AH, 2 ; preparo AH per la stampa





MOV DL, CR INT 21H ; stampo un carriage return MOV DL, LF INT 21H ; stampo un line feed MOV DL, DH INT 21H ; stampo il carattere .EXIT END





ESERCITAZIONE 9

Argomenti trattati: • I modi di indirizzamento: register, immediate, direct, register indirect, direct indexed. • L’input/output dei caratteri con INT21H.

Esercizi proposti:

Esercizio 19: Scrivere un programma Assembler che legga da tastiera un vettore di caratteri, lo ordini con l’algoritmo “bubble sort” e lo stampi su video.

Soluzione: ; programma che legge da tastiera un vettore ; di caratteri di lunghezza nota, lo ordina ; con l'algoritmo bubble sort e lo stampa su ; video DIM EQU 10 .MODEL SMALL .STACK .DATA VETT DB DIM DUP (?) .CODE .STARTUP MOV, 0 ; SI punta alla testa del vettore MOV AH, 1 ; preparo AH per la lettura INT 21H ; leggo un carattere MOV VETT[SI], AL ; pongo il carattere letto in VETT[0] leggi: INT 21H ; leggo lo spazio INC SI ; incremento SI INT 21H ; leggo un carattere MOV VETT[SI], AL ; pongo il carattere letto in VETT[SI] CMP SI, DIM-1 ; se SI != DIM -1 acquisisco JNZ leggi ; il prossimo carattere MOV SI, 1 ; inizializzo SI a 1 per il bubble sort





loop1: MOV DI, DIM-1 ; DI punta alla coda del vettore loop2: MOV BX, DI ; metto in BX il valore DEC BX ; DI -1 MOV AH, VETT[BX] ; confronto VETT[BX] con VETT[DI] CMP AH, VETT[DI] ; se VETT[BX] > VETT[DI] JLE nosc ; allora scambio il contenuto delle due caselle MOV AL, VETT[DI XCHG VETT[BX], AL MOV VETT[DI], AL nosc: DEC DI ; decremento DI CMP DI, SI , se DI < SI JNS loop2 ; itero nel loop interno INC SI ; Incrementa SI CMP SI, DIM ; Se SI != DIM JNZ loop1 ; itera nel loop esterno MOV SI, 0 ; SI punta alla testa di VETT MOV AH, 2 ; preparo AH per la stampa MOV DL, VETT[SI] ; carico DL con il carattere da stampare INT 21H ; stampo stampa: MOV DL, ' ' ; carico DL con lo spazio INT 21H ; stampo lo spazio INC SI ; incremento SI MOV DL, VETT[SI] ; carico DL con il carattere da stampare INT 21H ; stampo CMP SI, DIM-1 ; se SI != DIM - 1 JNZ stampa ; stampo il prossimo carattere .EXIT END

Esercizio 20: Scrivere un programma Assembler che legga da tastiera un carattere e stampi il carattere successivo secondo la codifica ASCII.

Soluzione: ; programma che legge da tastiera un carattere, ; e stampa il carattere successivo secondo la codifica ASCII .MODEL SMALL





.STACK .DATA .CODE .STARTUP MOV AH,1 ; preparo AH per la lettura INT 21H ; leggo un carattere MOV DH, AL ; metto il carattere in DH INC DH ; incremento il codice ASCII MOV DL, ' ' ; voglio stampare uno spazio MOV AH, 2 ; preparo AH per la stampa INT 21H ; stampo lo spazio MOV DL, DH ; stampo il carattere INT 21H .EXIT END





ESERCITAZIONE 10

Argomenti trattati: • Le istruzioni MUL e IMUL. • L’istruzione CBW.

Esercizi proposti:

Esercizio 21: Scrivere un programma Assembler che legga da tastiera due numeri compresi fra 0 e 9, li moltiplichi fra loro e stampi su video il risultato della moltiplicazione.

Soluzione: ; programma che legge da tastiera due numeri tra 0 e 9, ; li moltiplica tra di loro e stampa sul video il risultato ; della moltiplicazione DIM EQU 2 LF EQU 10 CR EQU 13 .MODEL SMALL .STACK .DATA DATI DB DIM DUP (?) .CODE .STARTUP MOV SI, 0 ; SI punta alla casella corrente di DATI next: MOV AH, 1 ; preparo AH per la lettura INT 21H ; leggo un numero MOV DATI[SI], AL ; e poi lo salvo in DATI[SI] MOV AH, 2 ; preparo AH per la scrittura MOV DL, LF ; vado alla prossima riga INT 21H MOV DL, CR ; vado a capo INT 21H INC SI ; incremento SI CMP SI, DIM ; se SI != DIM





JNE next ; salto a next MOV AL, DATI ; metto il primo dato in AL CMP AL, '0' ; se AL < '0' JB errinp ; non e' una cifra, salto a errinp CMP AL, '9' ; se AL > '9' JA errinp ; non e' una cifra, salto a errinp MOV BL, DATI+1 ; metto il secondo dato in BL CMP BL, '0' ; se BL < '0' JB errinp ; non e' una cifra, salto a errinp CMP BL, '9' ; se BL > '9' JA errinp ; non e' una cifra, salto a errinp SUB AL, '0' ; converto il primo dato in numero CBW ; estendo AL ad AX per la moltiplicazione SUB BL, '0' ; converto il secondo dato in binario MUL BL ; in AX ora c'e' BL*AL MOV BL, AL ; salvo in BL il risultato (parte bassa), AH = 0 CMP AX, 10 ; il risultato e' su due cifre ? JB una ; se no, salto a una MOV BH, 10 ; preparo BH per divisione DIV BH ; divido il risultato per 10 MOV BL, AH ; sposto il resto in BL MOV AH, 2 ; preparo AH per la stampa MOV DL, AL ; metto le decine in DL ADD DL, '0' ; converto in ASCII le decine INT 21H ; stampo le decine una: MOV AH, 2 ; preparo AH per la stampa MOV DL, BL ; metto il resto in DL ADD DL, '0' ; converti in ASCII le unita' INT 21H ; stampo le unita' JMP fine errinp: MOV AH, 2 ; preparo AH per la stampa MOV DL, '*' ; metto '*' in DL INT 21H ; stampo JMP fine fine: MOV DL, LF ; vado alla prossima riga INT 21H ; stampo MOV DL, CR ; vado a capo INT 21H ; stampo .EXIT END





Esercizio 22: Scrivere un programma Assembler che legga da tastiera un numero compreso fra 0 e 9, moltiplichi per tale numero un vettore di 5 numeri positivi su due cifre (cioè compresi fra 00 e 99), e stampi su video il massimo degli elementi del vettore così ottenuto purché sia maggiore di 100; in caso contrario il programma deve stampare il carattere ‘#’.

Soluzione: ; programma che legge da tastiera un numero tra 0 e 9, ; moltiplica per tale numero un vettore di 5 numeri positivi ; su due cifre (tra 00 e 99), e ne stampa su video il massimo ; solo se e' maggiore di 100, altrimenti stampa #. DIM EQU 5 LF EQU 10 CR EQU 13 MAXVAL EQU 100 .MODEL SMALL .STACK .DATA VETT DB DIM DUP (?) .CODE .STARTUP MOV AH, 1 ; preparo AH per la lettura INT 21H ; leggo il fattore moltiplicativo, lo metto in AL MOV BL, AL ; e poi lo salvo in BL MOV AH, 2 ; preparo AH per la scrittura MOV DL, LF ; vado alla prossima riga INT 21H MOV DL, CR ; vado a capo INT 21H CMP BL, '0' ; se BL < '0' JB errinp ; non e' una cifra, salto a errinp CMP BL, '9' ; se BL > '9' JA errinp ; non e' una cifra, salto a errinp SUB BL, '0' ; converti BL in cifra MOV SI, 0 ; SI punta alla casella corrente di VETT next: MOV AH, 1 ; preparo AH per la lettura INT 21H ; leggo la prima cifra SUB AL, '0' ; converto in binario





MOV BH, 10 ; preparo BH per la moltiplicazione MUL BH ; in AX ora c'e' BH*AL MOV VETT[SI], AL ; metto AL in VETT[SI] (decine), AH tutti zeri MOV AH, 1 ; preparo AH per la lettura INT 21H ; leggo la seconda cifra SUB AL, '0' ; converto ADD VETT[SI], AL ; completo la conversione MOV AH, 2 ; preparo AH per la scrittura MOV DL, LF ; vado alla prossima riga INT 21H MOV DL, CR ; vado a capo INT 21H INC SI ; incremento SI CMP SI, DIM ; ho caricato tutto il vettore ? JNE next ; se no, salto a next MOV CX, 0 ; CX contiene il massimo corrente MOV SI, 0 ; SI punta alla casella corrente prox: MOV AL, VETT[SI] ; elemento da moltiplicare MUL BL ; moltiplico AL*BL, risultato in AX CMP CX, AX ; confronto AX con il massimo corrente JAE nosc ; non scambio, salto a nosc XCHG AX, CX ; scambio AX e CX nosc: INC SI ; incremento SI CMP SI, DIM ; ho esplorato tutto il vettore ? JNE prox ; se no, salto a prox CMP CX, MAXVAL ; massimo > di MAXVAL ? JB minore ; se no, salto a minore MOV AX, CX ; metto il massimo in AX MOV BH, 100 ; preparo BH per la divisione DIV BH MOV DL, AL ; metto le centinaia in DL ADD DL, '0' ; converto in ASCII le centinaia MOV BL, AH ; sposto il resto in BL MOV AH, 2 ; preparo AH per la stampa INT 21H ; stampo le centinaia MOV AL, BL ; metto il resto il AL CBW ; trasformo AL in AX MOV BH, 10 ; preparo BH per la divisione DIV BH MOV DL, AL ; metto le decine in DL ADD DL, '0' ; converto in ASCII le decine





MOV BL, AH ; sposto il resto in BL MOV AH, 2 ; preparo AH per la stampa INT 21H ; stampo le decine MOV DL, BL ; metto il resto in DL ADD DL, '0' ; converto in ASCII le unita' INT 21H ; stampo le unita' JMP fine errinp: MOV AH, 2 ; preparo AH per la stampa MOV DL, '*' ; metto '*' in DL INT 21H ; stampo JMP fine minore: MOV AH, 2 ; preparo AH per la stampa MOV DL, '#' ; metto '#' in DL INT 21H ; stampo fine: MOV DL, LF ; vado sulla prossima riga INT 21H MOV DL, CR ; vado a capo INT 21H .EXIT END





ESERCITAZIONE 11

Argomenti trattati: • Le istruzioni DIV e IDIV. • L’istruzione LEA. • La stampa di stringhe.

Esercizi proposti:

Esercizio 23: Scrivere un programma Assembler che legga da tastiera due numeri positivi su due cifre (cioè compresi fra 00 e 99), e stampi su video il loro massimo comun divisore.

Soluzione: ; programma che legge da tastiera due numeri interi positivi su ; due cifre (tra 00 e 99), e ne stampa su video il massimo comun ; divisore LF EQU 10 CR EQU 13 .MODEL SMALL .STACK .DATA DATI DB 2 DUP (?) .CODE .STARTUP MOV SI, 0 ; SI punta alla casella corrente di DATI next: MOV AH, 1 ; preparo AH per la lettura INT 21H ; leggo la prima cifra SUB AL, '0' ; converto da ASCII a numero MOV BH, 10 ; preparo BH per la moltiplicazione MUL BH ; in AX ora c'e' BH*AL MOV DATI[SI], AL ; metto AL in DATI[SI] (decine), AH tutti zeri MOV AH, 1 ; preparo AH per la lettura INT 21H ; leggo la seconda cifra SUB AL, '0' ; converto ADD DATI[SI], AL ; completo la conversione





MOV AH, 2 ; preparo AH per la scrittura MOV DL, LF ; vado alla prossima riga INT 21H MOV DL, CR ; vado a capo INT 21H INC SI ; incremento SI CMP SI, 2 ; ho caricato tutto il vettore ? JNE next ; se no, salto a next MOV AL, DATI ; AL contiene il primo dato CBW ; converto il primo dato in WORD (in AX) MOV BL, DATI+1 ; BL contiene il secondo dato CMP BL, 0 ; se il secondo dato e' zero JE finito ; ho finito (MCD = 0) DIV BL ; divido il primo dato per il secondo ciclo: CMP AH, 0 ; il resto e' in AH JE finito ; se il resto e' 0 ho finito (MCD = secondo dato) MOV AL, BL ; aggiorno AL MOV BL, AH ; aggiorno BL CBW ; converto in WORD (in AX) DIV BL ; ricalcolo il resto (in AH) JMP ciclo ; salto a ciclo finito: MOV AL, BL ; metto MCD in AL CBW ; converto in WORD (in AX) CMP AX, 10 ; il risultato e' su due cifre ? JB una ; se no salto a una MOV BH, 10 ; preparo BH per divisione DIV BH ; divido il nuovo AX per 10 MOV BL, AH ; sposto il resto in BL MOV AH, 2 ; preparo AH per la stampa MOV DL, AL ; metto le decine in DL ADD DL, '0' ; converto in ASCII le decine INT 21H ; stampo le decine una: MOV AH, 2 ; preparo AH per la stampa MOV DL, BL ; metto il resto in DL ADD DL, '0' ; converto in ASCII le unita' INT 21h ; stampo le unita' MOV DL, LF ; vado sulla prossima riga INT 21H ; stampo MOV DL, CR ; vado a capo INT 21H ; stampo .EXIT END





Esercizio 24: Scrivere un programma Assembler che stampi su video una stringa per la richiesta di introduzione di un numero intero, legga il numero e stampi su video un messaggio che specifichi se il numero che è stato introdotto è pari o dispari.

Soluzione: ; programma che stampa su video una stringa per l’introduzione ; di un numero, decide se il numero è pari o dispari e visualizza ; un messaggio adeguato. LF EQU 10 CR EQU 13 .MODEL SMALL .STACK .DATA PROMPT DB 'Inserisci un numero: ','$' PARI DB "Il numero che hai scritto e' pari.",'$' DISPARI DB "Il numero che hai scritto e' dispari.","$" .CODE .STARTUP ; acquisisco un numero LEA DX, PROMPT ; metto in DX l'offset di PROMPT MOV AH, 9 ; preparo AH per la stampa di una stringa INT 21H ; stampo una stringa MOV AH, 1 ; preparo AH per la lettura di un carattere INT 21H ; leggo un carattere MOV BL, AL ; salvo AL in BL MOV AH, 2 ; preparo AH per la stampa di un carattere MOV DL, LF ; carattere LF in DL INT 21H ; stampo LF MOV DL, CR ; carattere CR in DL INT 21H ; stampo CR SUB BL, '0' ; converto il carattere in numero TEST BL, 1 ; controllo il bit meno significativo JZ par ; se il flag Z e' 1 il numero e' pari LEA DX, DISPARI ; metto in DX l'offset di DISPARI MOV AH, 9 ; preparo AH per la stampa di una stringa INT 21H ; stampo la stringa JMP fine par: LEA DX, PARI ; metto in DX l'offset di PARI MOV AH, 9 ; preparo AH per la stampa di una stringa





INT 21H ; stampo la stringa fine: MOV AH, 2 ; preparo AH per la stampa di un carattere MOV DL, LF ; carattere LF in DL INT 21H ; stampo LF MOV DL, CR ; carattere CR in DL INT 21H ; stampo CR .EXIT END





ESERCITAZIONE 12

Argomenti trattati: • Le istruzioni logiche: AND, OR, XOR e NOT. • Le istruzioni di scorrimento: SHL, SHR, SAL e SAR. • Le istruzioni di rotazione: ROL, ROR, RCL e RCR.

Esercizi proposti:

Esercizio 25: Scrivere un programma Assembler che legga da tastiera un carattere; se questo ha codice ASCII maggiore di 127, il programma deve sostituirlo con il carattere asterisco (*). Il programma deve scrivere nel bit più significativo del carattere ottenuto (che sicuramente è a 0) la “parità” del carattere (0 se il numero di bit uguali a 1 è pari, 1 in caso contrario), invertirlo e porre il risultato nella locazione di memoria SEND.

Soluzione: ; programma che legge da tastiera un carattere, e se ha codifica ; ASCII > 127 lo sostituisca con il carattere '*'. ; Sul carattere risultante scrive nel bit piu' significativo ; la "parita'" del carattere (0 se il numero di bit a 1 e' pari, ; 1 se e' dispari), lo inverte, e pone il risultato nella locazione ; SEND. LF EQU 10 CR EQU 13 STAR EQU '*' .MODEL SMALL .STACK .DATA SEND DB (?) .CODE .STARTUP next: MOV AH, 1 ; preparo AH per la lettura INT 21H ; leggo un carattere MOV BL, AL ; e poi lo salvo in BL MOV AH, 2 ; preparo AH per la scrittura





MOV DL, LF ; vado alla prossima riga INT 21H MOV DL, CR ; vado a capo INT 21H TEST BL, 80H ; AND di BL e 10000000b JZ minore ; se ZF=0 il codice e' <= di 127 MOV BL, STAR ; forzo il carattere a '*' minore: MOV CX, 8 ; inizializzo CX per il loop MOV DH, 0 ; azzero DH (contiene il numero di uni) MOV BH, BL ; faccio una copia del dato prox: SHR BH, 1 ; shifto a destra di una posizione JNC zero ; trovato uno zero INC DH ; incremento DH zero: LOOP prox ; prossimo bit TEST DH, 1H ; AND di DH e 00000001b JZ pari ; se ZF=0 il numero di uni e' pari OR BL, 80H ; OR di BL e 10000000b pari: MOV BH, 0 ; azzero BH, destinatario dell'inversione MOV CX, 7 ; inizializzo CX per il loop invert: SHL BL, 1 ; shifto a sinistra di una posizione JNC inzero ; estraggo uno zero OR BH, 80H ; estraggo un uno, lo inserisco in testa inzero: SHR BH, 1 ; shifto a destra di un posto lo zero o l'uno LOOP invert ; prossimo bit OR BH, BL ; sistemo l'ultimo bit MOV SEND, BH ; memorizzo il risultato in SEND .EXIT END

Esercizio 26: Scrivere un programma Assembler che legga da tastiera 8 numeri interi compresi fra 0 e 1 e li interpreti come la codifica ASCII di un carattere. Sul codice così .acquisito il programma deve esguire l’inversione e verificare la compatibilità fra il bit di parità (il più significativo) e la parità dei 7 bit meno significativi. Se il controllo dà risultato positivo il carattere deve essere memorizzato nella locazione di memoria REC e stampato su video, in caso contrario deve essere stampato su video il carattere ‘$’. Nota: questo programma deve esguire l’operazione inversa di quella prodotta dal programma dell’esercizio 25.





Soluzione: ; programma che legge da tastiera 8 numeri interi tra zero e uno, ; li interpreta come codifica ASCII di un carattere. ; Sul codice di 8 bit acquisito esegue l'inversione, verifica se c'e' ; corrispondenza tra il bit di parita' (il primo) e il dato (di 7 bit), ; Se il controllo ha successo, il carattere ricevuto e' memorizzato ; nella locazione REC e stampato su video, altrimenti stampa '$'. LF EQU 10 CR EQU 13 UNO EQU '1' ZERO EQU '0' STAR EQU '*' DOLLAR EQU '$' .MODEL SMALL .STACK .DATA REC DB (?) .CODE .STARTUP MOV BL, 0 ; BL conterra' il codice, lo azzero MOV CX, 7 ; inizializzo CX per il loop MOV AH, 1 ; preparo AH per la lettura next: INT 21H ; leggo un numero CMP AL, ZERO ; ho inserito uno zero ? JE inz ; se sì, salto a inz CMP AL, UNO ; ho inserito un uno ? JE inu ; se sì, salto a inu JMP errore ; nè zero nè uno, errore inu: OR BL, 1 ; inserisco un uno inz: SHL BL, 1 ; shifto a sinistra di un posto l'uno o lo zero LOOP next ; prossimo bit INT 21H ; acquisisco l'ultimo bit CMP AL, ZERO ; ho inserito uno zero ? JE lsz ; se sì, salto a lsz CMP AL, UNO ; ho inserito un uno ? JE lsu ; se sì, salto a lsu JMP errore ; nè zero nè uno, errore lsu: OR BL, 1 ; inserisco l'uno in testa lsz:





MOV BH, 0 ; azzero BH, destinatario dell'inversione MOV CX, 7 ; inizializzo CX per il loop invert: ROL BL, 1 ; shifto a sinistra di una posizione JNC inzero ; ho estratto uno zero OR BH, 80H ; ho estratto un uno, lo inserisco in testa inzero: SHR BH, 1 ; shifto a destra di un posto lo zero o l'uno loop invert ; prossimo bit TEST BL, 80H ; controllo l'ultimo bit JZ contr ; già ok, vado a contr OR BH, 80H ; sistemo l'ultimo bit contr: ROL BL, 1 ; completo la rotazione in BL MOV DL, 0 ; azzero DL, che conterra' indicazione sulla parita' TEST BH, 80H ; verifico il bit di parita' JZ pari ; bit di parita' = 0 INC DL ; DL = 1 perche' il dato e' dispari pari: MOV CX, 7 ; inizializzo CX per il loop MOV DH, 0 ; azzero DH (contiene il numero di uni) MOV BL, BH ; faccio una copia del dato prox: SHR BL, 1 ; shifto a destra di una posizione JNC trz ; ho trovato uno zero INC DH ; incremento DH trz: loop prox ; prossimo bit AND DH, 1H ; AND di DH e 00000001b CMP DH, DL ; controllo d'errore JNE p_err ; se DH != DL errore di parita' AND BH, 7FH ; elimino il bit di parita' MOV REC, BH ; copio il dato in REC MOV AH, 2 ; preparo AH per la scrittura MOV DL, LF ; vado alla prossima riga INT 21H MOV DL, CR ; vado a capo INT 21H MOV DL, BH ; metto il carattere in DL JMP fine ; salto a fine errore: MOV AH, 2 ; preparo AH per la scrittura MOV DL, LF ; vado alla prossima riga INT 21H MOV DL, CR ; vado a capo INT 21H MOV DL, STAR ; metto '*' in DL JMP fine ; salto a fine





p_err: MOV AH, 2 ; preparo AH per la scrittura MOV DL, LF ; vado alla prossima riga INT 21H MOV DL, CR ; vado a capo INT 21H MOV DL, DOLLAR ; metto '$' in DL fine: MOV AH, 2 ; preparo AH per la scrittura INT 21H ; stampo MOV DL, LF ; vado alla prossima riga INT 21H MOV DL, CR ; vado a capo INT 21H .EXIT END





ESERCITAZIONE 13

Argomenti trattati: • Le procedure. • Definizione di una procedura. • Chiamata di una procedura. • Ritorno da una procedura. • Salvataggio dei registri. • Passaggio dei parametri.

Esercizi proposti:

Esercizio 27: Scrivere una procedura Assembler che calcoli il massimo fra gli elementi di un vettore di numeri interi senza segno. I parametri di ingresso sono la lunghezza del vettore ed il suo offset. Il parametro di uscita è il massimo fra gli elementi del vettore. Scrivere inoltre un programma Assembler che richiami la procedura. I parametri di ingresso e di uscita devono essere passati come variabili globali.

Soluzione: ; procedura per il calcolo del massimo di un vettore di interi senza segno ; parametri di ingresso: lunghezza del vettore e offset del vettore ; passaggio parametri di ingresso: variabili globali ; parametri di uscita: massimo tra gli elementi del vettore ; passaggio dei parametri di uscita: variabili globali DIM EQU 10 .MODEL SMALL .STACK .DATA VETT DW 10,2,4,35,2,18,23,4,1,9 RES DW (?) .CODE .STARTUP CALL MASSIMO ; chiamata alla procedura MASSIMO .EXIT MASSIMO PROC NEAR ; procedura MASSIMO





PUSH AX ; salvo AX nello stack PUSH CX ; salvo CX nello stack PUSH SI ; salvo SI nello stack MOV SI, 0 ; SI punta al primo elemento del vettore MOV AX, 0 ; azzero AX, che conterra' il massimo MOV CX, DIM ; in CX metto il numero di elementi del vettore lab: CMP AX, VETT[SI] ; se AX > [BX] JAE cont ; non aggiorno AX e salto a cont MOV AX, VETT[SI] ; aggiorna AX con il nuovo massimo cont: ADD SI, 2 ; incremento SI LOOP lab ; prossimo elemento MOV RES, AX ; metto il massimo nella locazione RES POP SI ; ripristino SI POP CX ; ripristino CX POP AX ; ripristino AX RET ; ritorno al programma chiamante MASSIMO ENDP ; fine della procedura MASSIMO END

Esercizio 28: Scrivere una procedura Assembler che calcoli il massimo fra gli elementi di un vettore di numeri interi senza segno. I parametri di ingresso sono la lunghezza del vettore ed il suo offset. Il parametro di uscita è il massimo fra gli elementi del vettore. Scrivere inoltre un programma Assembler che richiami la procedura. I parametri di ingresso e di uscita devono essere passati tramite registri.

Soluzione: ; procedura per il calcolo del massimo di un vettore di interi senza segno ; parametri di ingresso: lunghezza del vettore e offset del vettore ; passaggio parametri di ingresso: registri ; parametri di uscita: massimo tra gli elementi del vettore ; passaggio dei parametri di uscita: registri DIM EQU 10 .MODEL SMALL .STACK .DATA VETT DW 10,2,4,35,2,18,23,4,1,9





RES DW (?) .CODE .STARTUP MOV AX, DIM ; in AX metto la lunghezza del vettore VETT LEA BX, VETT ; in BX l'offset del vettore VETT CALL MASSIMO ; chiamata alla procedura MASSIMO MOV RES, AX ; sposto il risultato da AX alla locazione RES .EXIT MASSIMO PROC NEAR ; procedura MASSIMO PUSH BX ; salvo BX nello stack PUSH CX ; salvo CX nello stack MOV CX, AX ; in CX metto il numero di elementi del vettore MOV AX, 0 ; azzero AX, che conterra' il massimo lab: CMP AX, [BX] ; se AX > [BX] JAE cont ; non aggiorno AX e salto a cont MOV AX, [BX] ; aggiorna AX con il nuovo massimo cont: ADD BX, 2 ; incremento BX di 2 LOOP lab ; prossimo elemento POP CX ; ripristino CX POP BX ; ripristino BX RET ; ritorno al programma chiamante MASSIMO ENDP ; fine della procedura MASSIMO END

Esercizio 29: Scrivere una procedura Assembler che calcoli il massimo fra gli elementi di un vettore di numeri interi senza segno. I parametri di ingresso sono la lunghezza del vettore ed il suo offset. Il parametro di uscita è il massimo fra gli elementi del vettore. Scrivere inoltre un programma Assembler che richiami la procedura. I parametri di ingresso devono essere passati tramite lo stack, quello di uscita tramite registro.

Soluzione: ; procedura per il calcolo del massimo di un vettore di interi senza segno ; parametri di ingresso: lunghezza del vettore e offset del vettore ; passaggio parametri di ingresso: stack ; parametri di uscita: massimo tra gli elementi del vettore ; passaggio dei parametri di uscita: registri





DIM EQU 10 .MODEL SMALL .STACK .DATA VETT DW 10,2,4,35,2,18,23,4,1,9 RES DW (?) .CODE .STARTUP MOV AX, DIM ; in AX metto la lunghezza del vettore VETT LEA BX, VETT ; in BX metto l'offset del vettore VETT PUSH AX ; passaggio del primo parametro PUSH BX ; passaggio del secondo parametro CALL MASSIMO ; chiamata alla procedura MASSIMO MOV RES, AX ; sposto il risultato da AX alla locazione RES POP DX ; libero lo stack dal primo parametro POP DX ; libero lo stack dal secondo parametro .EXIT MASSIMO PROC NEAR ; procedura MASSIMO PUSH BP ; salvo BP nello stack MOV BP,SP ; salvo lo stack pointer in BP PUSH BX ; salvo BX nello stack PUSH CX ; salvo CX nello stack MOV CX, [BP+6] ; in CX metto il numero di elementi del vettore MOV BX, [BP+4] ; in BX metto l'offset del vettore MOV AX, 0 ; azzero AX, che conterra' il massimo lab: CMP AX, [BX] ; se AX >= [BX] JAE cont ; non aggiorno AX e salto a cont MOV AX, [BX] ; aggiorno AX con il nuovo massimo cont: ADD BX, 2 ; incremento BX di 2 LOOP lab ; prossimo elemento POP CX ; ripristino CX POP BX ; ripristino BX POP BP ; ripristino BP RET ; ritorno al programma chiamante MASSIMO ENDP ; fine della procedura MASSIMO END





ESERCITAZIONE 14

Argomenti trattati: • Prova di autovalutazione.

Esercizio proposto:

Esercizio 30: Scrivere un programma Assembler che legga da tastiera un numero intero h compreso fra 0 e 9, e visualizzi sullo schermo un triangolo isoscele con base uguale ad h e altezza uguale a 2h-1. Esempio: con h=5 si ottiene il triangolo * *** ***** ******* *********





ESERCITAZIONE 15

Argomenti trattati: • Soluzione della prova di autovalutazione.

Esercizio proposto:

Esercizio 30: Scrivere un programma Assembler che legga da tastiera un numero intero h compreso fra 0 e 9, e visualizzi sullo schermo un triangolo isoscele con base uguale ad h e altezza uguale a 2h-1. Esempio: con h=5 si ottiene il triangolo * *** ***** ******* *********

Soluzione: ; programma che legge da tastiera un numero intero h ; copreso fra 0 e 9 e stampa un triangolo isoscele ; di * di altezza h e base 2h-1 ; codici ASCII LF EQU 10 ; line feed CR EQU 13 ; carriage return SPAZIO EQU ' ' ; spazio STAR EQU '*' ; asterisco ZERO EQU '0' ; zero NOVE EQU '9' ; nove .MODEL SMALL ; memory model: small .STACK ; segmento di stack (default 1 Kbyte) .DATA ; segmento di dati PROMPT DB 'Scrivi h: ','$' ERR_MSG DB 'Errore: Dato non corretto !!!','$' .CODE ; segmento di codice





.STARTUP ; acquisisco l'altezza del triangolo LEA DX, PROMPT ; metto in DX l'offset di PROMPT MOV AH, 9 ; preparo AH per la stampa di una stringa INT 21H ; stampo la stringa MOV AH, 1 ; preparo AH per la lettura di un carattere INT 21H ; leggo un carattere MOV BL, AL ; salvo AL in BL MOV AH, 2 ; preparo AH per la stampa di un carattere MOV DL, LF ; carattere LF in DL INT 21H ; stampo LF MOV DL, CR ; carattere CR in DL INT 21H ; stampo CR CMP BL, ZERO ; se BL < '0' JB err_inp ; il carattere non e' una cifra, salto a err_inp CMP BL, NOVE ; se BL > '9' JA err_inp ; il carattere non e' una cifra, salto a err_inp SUB BL, ZERO ; converto il codice ASCII nel numero corrispondente ; metto l'altezza del triangolo in BX MOV AL, BL ; copio BL in AL CBW ; estendo AL ad AX MOV BX, AX ; copio AX in BX ; stampo il triangolo CMP BX, 0 ; se BX = 0 (triangolo "nullo") JE fine ; salto a fine MOV SI, 1 ; SI indice del loop esterno riga: MOV DI, 1 ; DI indice del primo loop interno MOV CX, BX ; metto BX in CX SUB CX, SI ; calcolo il limite del primo loop interno spaz: CMP DI, CX ; se DI > CX JA cont ; stampo gli asterischi (salto a cont) MOV AH, 2 ; preparo AH per la stampa di un carattere MOV DL, SPAZIO ; carattere SPAZIO in DL INT 21H ; stampo un carattere INC DI ; incremento DI JMP spaz ; salto a spaz cont: MOV DI, 1 ; DI indice del secondo loop interno MOV AX, SI ; copio SI in AX, poi uso solo AL per la MUL MOV DL, 2 ; copio 2 in DL MUL DL ; AX = 2*AL (la parte alta di AX e' 0)





SUB AX, 1 ; AX = 2*AL - 1 (limite del secondo loop) MOV CX, AX ; pongo AX in CX MOV AH, 2 ; preparo AH per la stampa di un carattere MOV DL, STAR ; carattere STAR in DL ast: INT 21H ; stampo un carattere INC DI ; incremento DI CMP DI, CX ; se DI <= CX JBE ast stampo un altro asterisco (salta a ast) MOV DL, LF ; carattere LF in DL INT 21H ; stampo un carattere MOV DL, CR ; carattere CR in DL INT 21H ; stampo un carattere INC SI ; incremento SI CMP SI, BX ; se SI <= BX JBE riga ; stampo un'altra riga JMP fine ; salto a fine ; gestione dell'errore di immisione dati err_inp: MOV AH, 9 ; preparo AH per la stampa di una stringa LEA DX, ERR_MSG ; metto in DX l'offset in DS di ERR_MSG INT 21H ; stampo il messaggio d'errore ; fine delle operazioni fine: MOV AH, 2 ; preparo AH per la stampa di un carattere MOV DL, LF ; carattere LF in DL INT 21H ; stampo un carattere MOV DL, CR ; carattere CR in DL INT 21H ; stampo un carattere .EXIT END ; fine del programma





Esercizi svolti in aula. Raccolti e commentati da Marco Ferrasti.





04-10-99.asm ; Dati due vettori ordinati (in ordine crescente) di numeri senza segno su ; 16 bit VET1 e VET2, la cui dimensione Š specificata nei Byte DIM1 e DIM2 ; si scriva un programma Assembler che calcola gli elementi di un terzo ; vettore VET3 contenente tutti i numeri che compaiono o in VET1 o in VET2, ; eliminando i duplicati ed in ordine crescente. Il programma deve salvare ; all'indirizzo DIM3 il numero degli elementi di VET3 e, stampare il vettore ; sullo schermo .MODEL SMALL .STACK .DATA CR EQU 13 LF EQU 10 DIM1 EQU 3 ; Totale numeri in VET1 DIM2 EQU 5 ; Totale numeri in VET2 DIM3 DW ? ; Totale numeri in VET3 VET1 DW 12,23,1099 VET2 DW 0,23,85,1099,4097 VET3 DW 256 DUP (?) VET DB 5 DUP (?) .CODE SCRIVI PROC NEAR PUSH CX ; Salva il contatore di elementi XOR DI,DI ; Azzera cont. caratteri del numero MOV AX,DX ; Copia l'elemento v(i) in AX XOR DX,DX MOV BX,10 ; Preparati per la conversione CICLO:DIV BX ; Dividi AX per 10 ADD DL,'0' ; Converti il resto in ASCII MOV VET[DI],DL ; Scrivilo nel VET INC DI ; Incrementa il contatore XOR DX,DX ; Azzera il registrp CMP AX,0 ; Confronta il risultato con '0' JNZ CICLO ; Se non Š vero ripeti MOV CX,DI ; Altrimanti copia il contatore DEC DI ; Decrementa i caratteri del numero CICLO1:MOV DL,VET[DI] ; Parti dall'ultimo numero MOV AH,2 INT 21H ; Stampa il numero DEC DI LOOP CICLO1 ; Termina con la stampa delle decine MOV AH,2 ; Vai a capo MOV DL,CR INT 21H MOV DL,LF INT 21H POP CX ; Recupera il contatore del vettore RET SCRIVI ENDP ESEGUI PROC NEAR XOR SI,SI XOR DI,DI XOR CX,CX ; Contatore di elementi in VET3 XOR AH,AH ; Dice quando ho finito VET1 XOR AL,AL ; Dice quando ho finito VET2 LEA SI,VET1 ; Associa SI a VET1 LEA DI,VET2 ; Associa DI a VET2 PROSS:MOV BX,[SI] ; Prendi l'elemento da VET1 MOV DX,[DI] ; Prendi l'elemento da VET2





CMP BX,DX ; Confronta i due elementi JB VET1MIN ; Se VET1(SI)<VET2(DI) salta CMP BX,DX ; Confronta i due elementi JA VET2MIN ; Se VET1(SI)>VET2(DI) salta PUSH BX ; Qui ci arrivo se sono uguali ADD SI,2 ; Incremento punt. elementi di VET1 ADD DI,2 ; Incremento punt. elementi di VET2 INC CX ; Incremento cont. elementi di VET3 INC AH ; Incremento cont. elementi di VET1 INC AL ; Incremento cont. elementi di VET2 JMP FINECONF ; Salta a fine confronti VET1MIN:PUSH BX ; Qui ci arrivo se BX Š il minore ADD SI,2 ; Incremento punt. elementi di VET1 INC CX ; Incremento cont. elementi di VET3 INC AH ; Incremento cont. elementi di VET1 JMP FINECONF ; Salta a fine confronti VET2MIN:PUSH DX ; Qui ci arrivo se DX Š il minore ADD DI,2 ; Incremento punt. elementi di VET2 INC CX ; Incremento cont. elementi di VET3 INC AL ; Incremento cont. elementi di VET2 FINECONF:CMP AH,DIM1 ; Ho finito VET1 ? JE FINEVET1 ; Se uguale salta a fine vettore 1 CMP AL,DIM2 ; Ho finito VET2 ? JE FINEVET2 ; Se uguale salta a fine vettore 2 JMP PROSS ; Altrimenti riprendi a confrontare FINEVET2:MOV BX,[SI] ; Devo copiare tutto il VET1 PUSH BX ; Salva sullo stack l'elemento ADD SI,2 ; Incremento punt. elementi di VET1 INC CX ; Incremento cont. elementi di VET3 INC AH ; Incremento cont. elementi di VET1 CMP AH,DIM1 ; Ho finito VET1 ? JE FINITO ; Se uguale alta a FINITO JMP FINEVET1 ; Altrimenti ritorna a FINEVET1 FINEVET1:MOV DX,[DI] ; Devo copiare tutto il VET1 PUSH DX ; Salva sullo stack l'elemento ADD DI,2 ; Incremento punt. elementi di VET2 INC CX ; Incremento cont. elementi di VET3 INC AL ; Incremento cont. elementi di VET2 CMP AL,DIM2 ; Ho finito VET2 ? JE FINITO ; Se uguale alta a FINITO JMP FINEVET1 ; Altrimenti ritorna a FINEVET1 FINITO:MOV [DIM3],CX ; In CX ora ho il numero di elementi in VET3 XOR SI,SI LEA SI,VET3 COPIA:POP DX ; Riprendi l'elemento dallo stack MOV [SI],DX ; Scrivilo sul VET3 ADD SI,2 ; Incrementa il puntatore LOOP COPIA ; Ripeti per CX volte ; Ora il VET3 Š in ordine decrescente MOV CX,[DIM3] XOR SI,SI LEA SI,VET3 INVERTI:MOV DX,[SI] PUSH DX ADD SI,2 LOOP INVERTI ; Ripeti CX volte ; Ora sullo stack ho VET3 in ordine crescente MOV CX,[DIM3] XOR SI,SI LEA SI,VET3 RICOPIA:POP DX ; Riprendi l'elemento dallo stack MOV [SI],DX ; Scrivilo sul VET3 ADD SI,2 ; Incrementa il puntatore LOOP RICOPIA ; Ripeti per CX volte ; Ora il VET3 Š in ordine crescente RET ESEGUI ENDP .STARTUP





CALL ESEGUI XOR SI,SI ; Azzera il puntatore LEA SI,VET3 ; Associa SI al vettore MOV CX,[DIM3] ; Metti in CX la sua dimensione INIZIO:MOV DX,[SI] ; Prendi il primo elemento CALL SCRIVI ; Scrivilo sul video in decimale ADD SI,2 ; Passa e quello successivo LOOP INIZIO .EXIT END





21-7-99.asm ; Si scriva un programma Assembler che simuli il comportamento di una calco- ; latrice decimale. Il programma deve: ; 1) accettare da tastiera un'espressione aritmetica del tipo: ; <numero><operatore><numero><a capo> ; dove <numero> Š un numero decimale composto al pi— da quattro cifre ; <operatore> Š uno dei quattro simboli +,-,*,/ ; 2) eseguire l'operazione richiesta ; 3) visualizzare il risultato in decimale .MODEL SMALL .STACK .DATA MAX EQU 4 ; Grandezza masima degli operandi CR EQU 13 LF EQU 10 MES1 DB "Numero troppo grande ",CR,LF,CR,LF,"$" MES2 DB "Non hai immesso un numero ",CR,LF,CR,LF,"$" MES3 DB "Il risultato Š : ","$" NUM1 DW 1 DUP (?) ; Conterr… il primo valore NUM2 DW 1 DUP (?) ; Conterr… il secondo valore OPER DB 1 DUP (?) ; Conterr… l'operatore VET DB 5 DUP (?) ; Utilizzato per la stampa .CODE ACAPO PROC NEAR ; Procdura che va a capo PUSH DX PUSH AX MOV AH,2 MOV DL,CR INT 21H MOV DL,LF INT 21H POP AX POP DX RET ACAPO ENDP LEGGI PROC NEAR PUSH AX ; Salva il registro AX LEA SI,NUM1 ; Associa SI al primo numero INIZIO1:XOR CL,CL ; Contatore di MAX 4 caratteri CALL ACAPO XOR DX,DX ; Azzera il registro per la lettura CONTINUA:MOV AH,1 ; Predisponi la lettura da tastiera INT 21H ; Leggi il carattere (in AL) CMP AL,'+' JE AVANTI CMP AL,'-' JE AVANTI CMP AL,'*' JE AVANTI CMP AL,'/' JE AVANTI CMP AL,'9' ; Confrontalo con il carattere "9" JA ERRORE2 ; Se (NUM>9) salta a ERRORE2 CMP AL,'0' ; Confrontalo con il carattere "0" JB ERRORE2 ; Se (NUM<0) salta a ERRORE2 SUB AL,'0' ; Ora in AL ho il numero DECIMALE CALL MOLTIPLICA ; AX=NUM1 DX=0*10=0 (alla fine del I giro) ; AX=NUM2 DX=NUM1*10 (alla fine del II giro) XOR AH,AH ; Azzera la parte alta di AX ADD DX,AX ; DX=DX+AX INC CL ; Incrementa il contatore di caratteri CMP CL,MAX ; Confronta con il numero massimo





JA ERRORE1 ; Se CL>MAX salta a ERRORE1 JMP CONTINUA ; Altrimenti salta a CONTINUA ERRORE2:XOR DX,DX LEA DX,MES2 MOV AH,9 INT 21H ; Stampa "Non Š un numero " XOR DX,DX JMP INIZIO1 ; Ricomincia ERRORE1:XOR DX,DX LEA DX,MES1 MOV AH,9 INT 21H ; Stampa "Numero troppo grande " XOR DX,DX JMP INIZIO1 ; Ricomincia AVANTI:MOV [SI],DX LEA DI,OPER MOV [DI],AL XOR SI,SI ; Azzera il puntatore LEA SI,NUM2 ; Associa SI al secondo numero INIZIO2:XOR CL,CL ; Contatore di MAX 4 caratteri XOR DX,DX ; Azzera il registro per la lettura CONTINUA2:MOV AH,1 ; Predisponi la lettura da tastiera INT 21H ; Leggi il carattere (in AL) CMP AL,CR ; Confronta con "RETURN" JZ FINE ; Se vero vai alla FINE CMP AL,'9' ; Confrontalo con il carattere "9" JA ERRORE4 ; Se (NUM>9) salta a ERRORE2 CMP AL,'0' ; Confrontalo con il carattere "0" JB ERRORE4 ; Se (NUM<0) salta a ERRORE2 SUB AL,'0' ; Ora in AL ho il numero DECIMALE CALL MOLTIPLICA ; AX=NUM1 DX=0*10=0 (alla fine del I giro) ; AX=NUM2 DX=NUM1*10 (alla fine del II giro) XOR AH,AH ; Azzera la parte alta di AX ADD DX,AX ; DX=DX+AX INC CL ; Incrementa il contatore di caratteri CMP CL,MAX ; Confronta con il numero massimo JA ERRORE3 ; Se CL>MAX salta a ERRORE1 JMP CONTINUA2 ; Altrimenti salta a CONTINUA ERRORE4:XOR DX,DX LEA DX,MES2 MOV AH,9 INT 21H ; Stampa "Non Š un numero " XOR DX,DX JMP INIZIO2 ; Ricomincia ERRORE3:XOR DX,DX LEA DX,MES1 MOV AH,9 INT 21H ; Stampa "Numero troppo grande " XOR DX,DX JMP INIZIO2 ; Ricomincia FINE:MOV [SI],DX POP AX ; Recupera il valore iniziale di AX RET LEGGI ENDP ESEGUI PROC NEAR XOR SI,SI XOR DI,DI LEA SI,NUM1 LEA DI,NUM2 MOV AX,[SI] ; Prendi il primo operando MOV BX,[DI] ; Prendi il secondo operando XOR SI,SI LEA SI,OPER MOV CL,[SI] ; Prendi l'operatore CMP CL,'+' JZ PIU CMP CL,'-'





JZ MENO CMP CL,'*' JZ PER CMP CL,'/' JZ DIVISO PIU:ADD AX,BX ; AX = AX + BX JMP ADDIO MENO:SUB AX,BX ; AX = AX - BX JMP ADDIO PER:MUL BX ; AX = AX * BX JMP ADDIO DIVISO:DIV BX ; AX = AX / BX JMP ADDIO ADDIO:RET ESEGUI ENDP STAMPA PROC NEAR PUSH AX ; Salva il risultato dell'operazione XOR DX,DX LEA DX,MES3 MOV AH,9 ; Stampa "Il risultato Š : " INT 21H POP AX ; Riprendi il risultato dell'operazione XOR DI,DI ; Azzera il puntatore XOR DX,DX MOV BX,10 CICLO:DIV BX ADD DL,'0' ; Trasforma in ASCII MOV VET[DI],DL ; Metti il resto nel vettore INC DI XOR DX,DX CMP AX,0 ; Confronta il risultato della DIV con 0 JNZ CICLO ; Se non uguale a zero ripeti MOV CX,DI DEC DI ; Ora DI punta all'ultimo elemento CICLO1:MOV DL,VET[DI] MOV AH,2 ; Predisponi la scrittura su video INT 21H DEC DI LOOP CICLO1 CALL ACAPO RET STAMPA ENDP MOLTIPLICA PROC NEAR PUSH AX PUSH CX MOV AX,DX MOV CX,10 MUL CX MOV DX, AX POP CX POP AX RET MOLTIPLICA ENDP .STARTUP CALL LEGGI CALL ESEGUI CALL STAMPA .EXIT END





26-05-99.asm ; Si scriva un programma Assembler che permetta di eseguire delle ricerche ; all'interno di un elenco di prodotti.L'elenco Š memorizzato in un VETT ;, che per ogni prodotto contiene il nome (terminato da '$') ed il quantita- ; tivo (su 2 byte).Il numero di prodotti Š contenuto in una variabile TOT. .MODEL SMALL .STACK .DATA TOT DB 7 ; Numero di prodotti CR EQU 13 LF EQU 10 MES1 DB "Non ho trovato il prodotto ",CR,LF,CR,LF,"$" MES2 DB "Il risultato Š : ","$" VETT DB "mele$21pere$24banane$70arance$38prugne$90banane$12mele40" PROD DB 20 DUP (?) ; Conterr… il prodotto immesso VET DB 5 DUP (?) ; Utilizzato per la stampa .CODE ACAPO PROC NEAR ; Procdura che va a capo PUSH DX PUSH AX MOV AH,2 MOV DL,CR INT 21H MOV DL,LF INT 21H POP AX POP DX RET ACAPO ENDP LEGGI PROC NEAR ; Procedura che legge un prodotto CALL ACAPO XOR CH,CH ; Numero di caratteri del prodotto XOR SI,SI ; Azzera il puntatore LEA SI,PROD ; Associa SI al vettore PROD SUCC:MOV AH,1 INT 21H ; Leggi il carattere CMP AL,CR ; Confronta con "RETURN" JZ FINITO ; Se vero ho finito MOV [SI],AL ; Atrimenti memorizza nel vettore INC SI ; Incrementa il puntatore INC CH ; Incrementa il contatore JMP SUCC ; Ritorna a succ FINITO:RET LEGGI ENDP CALCOLA PROC NEAR XOR BX,BX ; Conterr… il risultato finale XOR DI,DI MOV AL,TOT[DI] ; Numero di ricerche del prodotto MOV CL,-1 ; Contatore di ricerche XOR SI,SI XOR DI,DI LEA SI,VETT ; Associa SI al vettore dei prodotti CIC1:PUSH AX ; PerchŠ AL verr… modificato INC CL XOR AH,AH ; Conta quanti caratteri uguali CMP CL,AL ; Ho raggiunto il massimo delle ricerche? JE TERM ; Se CL=AL ho finito le ricerche SOPRA:CMP AH,CH ; Ho finito i caratteri del prodotto? JZ AVANTI ; Se ho finito vado avanti MOV DL,[SI] ; Prendi il carattere dal vettore





MOV DH,PROD[DI] ; Prendi il carattere dal prodotto CMP DL,DH ; Confrontali JNZ ALTRO ; Se diversi passa ad un altro confronto INC AH ; Altrimenti incrementa caratteri uguali INC SI ; Incrementa il puntatore al vettore INC DI ; Incrementa il puntatore al prodotto JMP SOPRA ALTRO:INC SI ; Vai avanti finchŠ non trovi '$' MOV DL,[SI] CMP DL,'$' JNZ ALTRO ADD SI,3 ; Salta il quantitativo (2 byte) XOR DI,DI ; Posizionati sul primo carattere del prodotto JMP CIC1 AVANTI:XOR DX,DX ; Utilizzato per la conversione INC SI ; Salta il carattere '$' MOV AL,[SI] ; Prendi la prima cifra SUB AL,'0' ; Converti in binario CALL MOLTIPLICA ; Ritorna: AX=Cifra1 ----- DX=0*10=0 XOR AH,AH ; Azzera la parte alta ADD DX,AX ; DX=Prima Cifra INC SI MOV AL,[SI] ; Prendi la seconda cifra SUB AL,'0' ; Converti in binario CALL MOLTIPLICA ; Ritorna: AX=Cifra2 ---- DX=Cifra1*10 XOR AH,AH ; Azzera la parte alta di AX ADD DX,AX ; DX=Cifra1*10 + Cifra2 ADD BX,DX ; Aggiorna il risultato POP AX ; Recupera il numero massimo di ricerche JMP CIC1 TERM:RET CALCOLA ENDP STAMPA PROC NEAR XOR DX,DX LEA DX,MES2 MOV AH,9 ; Stampa "Il risultato Š : " INT 21H MOV AX,BX ; Metti in AX il numero da stampare XOR DI,DI ; Azzera il puntatore XOR DX,DX MOV BX,10 CICLO:DIV BX ADD DL,'0' ; Trasforma in ASCII MOV VET[DI],DL ; Metti il resto nel vettore INC DI XOR DX,DX CMP AX,0 ; Confronta il risultato della DIV con 0 JNZ CICLO ; Se non uguale a zero ripeti MOV CX,DI DEC DI ; Ora DI punta all'ultimo elemento CICLO1:MOV DL,VET[DI] MOV AH,2 ; Predisponi la scrittura su video INT 21H DEC DI LOOP CICLO1 CALL ACAPO RET STAMPA ENDP MOLTIPLICA PROC NEAR PUSH AX PUSH CX MOV AX,DX MOV CX,10 MUL CX MOV DX, AX POP CX POP AX





RET MOLTIPLICA ENDP .STARTUP CALL LEGGI CALL CALCOLA CMP BX,0 JZ ERRORE ; Se BX=0 non ho trovato il prodotto CALL STAMPA ; Altrimenti stampa in decimale il risultato JMP FINEPROG ; Salta a Fine Programma ERRORE:XOR DX,DX LEA DX,MES1 MOV AH,9 INT 21H FINEPROG: .EXIT END





990324.asm ; esame del 24/03/99 .model small .stack .data cr equ 13 lf equ 10 fine db "00 00 0000","$" ; dollaro terminatore di oggetto date db 256 dup (?) ; vettore che useremo per memorizzare le date supp db 10 dup (?) ; vettore di supporto per controllo data message db "immettere la data (gg mm aaaa) ",cr,lf,"$" .code a_capo proc near mov ah, 02h mov dl, cr int 21h mov dl, lf int 21h ret a_capo endp vis_mes proc near xor dx, dx lea dx, message mov ah, 09h int 21h ret vis_mes endp leggi proc near push cx nuovo: call a_capo xor cx, cx ; contatore di caratteri xor si,si altro: mov ah, 01h int 21h cmp cx,10 jz finito cmp al, cr ; legge un carattere e lo confronta con invio jz finito mov supp[si], al inc si inc cx jmp altro finito: xor si, si riempi: mov al, supp[si] mov date[di], al inc si inc di loop riempi push di ; devo salvare il puntatore a date call controlla pop di ; recupero il contatore cmp dl,1 jz finiscila pop cx inc cx jmp nuovo





finiscila: pop cx ret leggi endp controlla proc near push si mov dl, 0 ; =0 se le date sono diverse ; =1 se la data immessa e' la terminatrice xor si, si xor di, di mov cx,10 ini: mov bh, supp[si] mov bl, fine[di] cmp bh, bl jnz no_fine ; la data non e' la terminatrice inc si inc di loop ini si_fine: mov dl,1 jmp era_ora no_fine: mov dl,0 era_ora: pop si ret controlla endp .startup call vis_mes xor cx, cx xor di,di call leggi .exit end





compresi.asm ; trova in un vettore di numeri interi con segno, quanti sono ; compresi tra MIN e MAX .MODEL SMALL .STACK .DATA DIM EQU 5 ; Dimensione del vettore MIN EQU 0 ; Limite inferiore MAX EQU 3000 ; Limite superiore VET DW 1234,-23,-78,2056,2980 ; Numeri decimali senza segno .CODE CALCOLA PROC NEAR ; Procedura che calcola MIN e MAX XOR AX,AX ; Variabil contatore XOR SI,SI ; Azzera il puntatore LEA SI,VET ; Associa puntatore a WORD MOV CX,DIM ; Inizializza variabile di ciclo CICLO:MOV BX,[SI] CMP BX,MIN JL SUCCESSIVO ; Se VET(SI)<MIN vai al SUCCESSIVO CMP BX,MAX JG SUCCESSIVO ; Se VET(SI)>MAZ vai al SUCCESSIVO INC AX ; Altrimenti incrementa il contatore SUCCESSIVO:ADD SI,2 LOOP CICLO ; Decrementa CX e torna a CICLO RET CALCOLA ENDP .STARTUP CALL CALCOLA .EXIT END /





confront.asm ;Questo programma riceve due stringe terminanti in 0 da tastiera e ;stampa "UGUALI" o "DIVERSI" .model small .stack .data parola1 DB "MAURIZIO0" parola2 DB "GALZIGNATO0" OK DB "UGUALI","$" NOK DB "DIVERSI","$" .code conta1 proc near ; conta il numero di caratteri mov cx,-1 ; in PAROLA1 nel registro CX mov si,-1 ciclo1: inc cx inc si cmp parola1[si],'0' jnz ciclo1 ret conta1 endp ; conta il numero di caratteri conta2 proc near ; in PAROLA2 nel registro BX mov bx,-1 mov si,-1 ciclo2: inc bx inc si cmp parola2[si],'0' jnz ciclo2 ret conta2 endp confronta proc near xor si,si ; Azzera il puntatore a caratere ciclo:mov al,parola1[si] ; AL contiene il carattere di PAROLA1 mov bl,parola2[si] ; BL contiene il carattere di PAROLA2 cmp al,bl ; li confronta jnz diversi ; se diversi esce dal ciclo inc si ; altrimenti passa ai caratt. successivi loop ciclo ; decrementa CX e torna a CICLO xor dx,dx ; N.B.qui ci arriva solo se le due parole mov ah,9 ; sono uguali e stampa che lo sono lea dx,ok int 21H jmp fineproc diversi:xor dx,dx ; N.B.qui ci arriva se le due parole mov ah,9 ; hanno lunghezza uguale ma sono lea dx,nok ; diverse int 21H fineproc:ret confronta endp .startup call conta1 ; conta i caratteri di PAROLA1 call conta2 ; conta i caratteri di PAROLA2 cmp cx,bx ; confronta le lunghezze jnz fine ; se non sono ugluali vai alla FINE call confronta ; altrimenti confronta caratt.x caratt. jmp uscita ; salta all'uscita





fine:xor dx,dx ; N.B.qui ci arriva solo se le due mov ah,9 ; lunghezze sono diverse lea dx,nok int 21H uscita: .exit END





conta.asm ; conta il numero di elementi di un vettore di word che termina con -1 .MODEL SMALL .STACK .DATA VET DW 1H,2H,3H,4H,-1H ; Numero Esadevimali con segno .CODE CONTA PROC NEAR ; Procedura che conta gli elementi XOR BX,BX ; Azzera puntatore a WORD MOV CX,-1 ; N.B. Parto da un numero in meno MOV BX,-2 ; perche VET pu• essere vuoto CICLO:INC CX ; Incrementa il contatore ADD BX,2 ; Passa alla WORD successiva CMP VET[BX],-1 JNZ CICLO ; Se non uguale torna a CICLO RET CONTA ENDP .STARTUP CALL CONTA .EXIT END





galzy001.asm ;Legge due parole da tastiera (terminate da "return") ;Poi le stampa su video con un segno "-&-" in mezzo .MODEL SMALL .STACK .DATA PAROLA1 DB 80 DUP (?) ; Definisce la prima stringa PAROLA2 DB 80 DUP (?) ; Definisce la seconda stringa PARTOT DB 80 DUP (?) ; Definisce parola totale CR EQU 13 ; Definisce il "FINE STRINGA" ACAPO DB 13,10,"$" ; Definisce il "VAI A CAPO" TRA DB ' ','&',' ',"$" ; Definisce in mezzo .CODE VAIACAPO PROC NEAR ; Procedura "VAI A CAPO" PUSH DX ; Salva il registro XOR DX,DX ; Azzera il registro per l'output MOV AH,9 ; Predispone l'output del VAI A CAPO LEA DX,ACAPO ; Associa DX alla stringa INT 21H ; Stampa la stringa POP DX ; Recupera il registro DX RET VAIACAPO ENDP LEGGI1 PROC NEAR ; Procedura che legge la prima parola XOR CX,CX ; Azzera contatore parola 1 XOR SI,SI ; Azzera puntatore a carattere LEA SI,PAROLA1 ; Associa puntatore SI a PAROLA1 CICLO1:MOV AH,1 ; Predispone l' input da tastiera INT 21H ; Legge il carattere CMP AL,CR ; Confronta con la FINE JZ ESCI1 ; Se vero esci dal ciclo INC SI ; Incrementa il puntatore INC CX ; Incrementa in contatore MOV [SI],AL ; Scrivi il carattere in PAROLA1 JMP CICLO1 ; Salta a CICLO1 ESCI1:INC SI ; In queste istruzioni devo sostituire MOV DL,'$' ; scrivere sulla stringa il carattere MOV [SI],DL ; di "FINE STRINGA" (Š NECESSARIO) RET LEGGI1 ENDP LEGGI2 PROC NEAR ; Procedura che legge la seconda parola XOR BX,BX ; Azzera contatore parola 2 XOR DI,DI ; Azzera Puntatore a carattere LEA DI,PAROLA2 ; Associa puntatore DI a PAROLA 2 CICLO2:MOV AH,1 INT 21H CMP AL,CR JZ ESCI2 INC DI INC BX MOV [DI],AL JMP CICLO2 ESCI2: INC DI MOV DL,'$' MOV [DI],DL RET LEGGI2 ENDP STAMPA PROC NEAR ; Procedura che stampa XOR DX,DX ; Azzera il registro per l'output MOV AH,9 ; Predispone output della stringa





LEA DX,PAROLA1 ; Associa DX a PAROLA1 INT 21H ; Visualizza PAROLA1 XOR DX,DX MOV AH,9 LEA DX,TRA INT 21H ; Visualizza "-&-" XOR DX,DX MOV AH,9 LEA DX,PAROLA2 INT 21H ; Visualizza PAROLA2 RET STAMPA ENDP .STARTUP CALL LEGGI1 CALL VAIACAPO CALL LEGGI2 CALL VAIACAPO CALL STAMPA CALL VAIACAPO .EXIT END





galzy002.asm ;Legge legge da tastiera un stringa terminata da "RETURN" ;legge un carattere e conta in BX quante volte compare .MODEL SMALL .STACK .DATA PAROLA1 DB 80 DUP (?) ; Definisce la prima stringa CARATTE DB 1 DUP (?) CR EQU 13 ; Definisce il "FINE STRINGA" ACAPO DB 13,10,"$" ; Definisce il "VAI A CAPO" .CODE VAIACAPO PROC NEAR ; Procedura "VAI A CAPO" PUSH DX ; Salva il registro XOR DX,DX ; Azzera il registro di uscita LEA DX,ACAPO ; Associa DX alla stringa MOV AH,9 ; Predispone la stampa di una stringa INT 21H ; Stampa la stringa POP DX ; Recupera il registro DX RET VAIACAPO ENDP LEGGI1 PROC NEAR ; Procedura che legge la prima parola XOR CX,CX ; Azzera contatore parola 1 XOR SI,SI ; Azzera puntatore a carattere LEA SI,PAROLA1 ; Associa puntatore SI a PAROLA1 CICLO1:MOV AH,1 ; Predispone la lettura da tastiera INT 21H ; Legge il carattere CMP AL,CR ; Confronta con la FINE JZ ESCI1 ; Se vero esci dal ciclo XOR AH,AH ; Azzera la parte alta di AX MOV DX,AX ; Copia il carattere in DX INC SI ; Incrementa il puntatore INC CX ; Incrementa in contatore MOV [SI],DX ; Scrivi il carattere in PAROLA1 JMP CICLO1 ; Salta a CICLO1 ESCI1: RET LEGGI1 ENDP LEGGI2 PROC NEAR ; Procedura che legge il carattere XOR SI,SI ; Azzera Puntatore a carattere LEA SI,CARATTE ; Associa puntatore SI a CARATTE MOV AH,1 INT 21H ; Leggi il carattere in AL XOR AH,AH ; Azzera la parte alta di AX (era = 1) MOV DX,AX ; Copia il carattere in DX MOV [SI],DX ; Scrivi il carattere RET LEGGI2 ENDP CALCOLA PROC NEAR XOR SI,SI ; Azzera il puntatore XOR BX,BX ; Azzera il contatore LEA SI,CARATTE ; Associa il puntatore SI al carattere MOV DX,[SI] ; Prendi il carattere da confrontare LEA SI,PAROLA1 ; Associa il puntatore SI alla stringa CICLO:MOV AX,[SI] ; Prendi il carattere dalla stringa CMP AH,DL ; Confronta i due caratteri JNZ SUCCESSIVO ; Se non uguali vai a SUCCESSIVO INC BX ; Altrimenti sono uguali ed incr. il cont. SUCCESSIVO:INC SI ; incrementa il puntatore LOOP CICLO ; Decrementa CX e salta a CICLO





RET CALCOLA ENDP .STARTUP CALL LEGGI1 CALL VAIACAPO CALL LEGGI2 CALL VAIACAPO CALL CALCOLA .EXIT END





inp-vet.asm ; Programma che legge un vettore di N numeri (interi senza segno a 16 Bit) ; e lo visualizza sul video .MODEL SMALL .STACK .DATA CR EQU 13 LF EQU 10 MES1 DB " Immetti i numeri del vettore : ",CR,LF,CR,LF,"$" MES2 DB " Visualizzazione del vettore : ",CR,LF,CR,LF,"$" N EQU 10 ; Numero di elementi V1 DW 256 DUP (?) ; Vettore VET DB 5 DUP (?) ; Utilizzato per la converssione .CODE LEGGI PROC NEAR LEA DX,MES1 MOV AH,9 ; Stampa il Messaggio 1 INT 21H MOV CX,N XOR SI,SI LEA SI,V1 ALTNUM:MOV AH,2 MOV DL,CR INT 21H MOV DL,LF INT 21H XOR DX,DX ALTCAR:MOV AH,1 ; Predisponi la lettura di un carattere INT 21H CMP AL,CR JZ FINE ; Se RETURN vai alla fine dell'inserimento CMP AL,'9' JA ALTCAR ; Se maggiore di 9 reinserisci CMP AL,'0' JB ALTCAR ; Se minore di 0 reinserisci SUB AL,'0' ; Converti in Binario CALL MOLTIPLICA ; Esce il valore*10 solo alla fine del II giro XOR AH,AH ADD DX,AX ; Somma le unit… JMP ALTCAR FINE:MOV [SI],DX ; scrivi nel vettore ADD SI,2 LOOP ALTNUM MOV AH,2 ; Vai a capo MOV DL,CR INT 21H MOV DL,LF INT 21H RET LEGGI ENDP SCRIVI PROC NEAR PUSH CX ; Salva il contatore di elementi XOR DI,DI ; Azzera cont. caratteri del numero MOV AX,DX ; Copia l'elemento v(i) in AX XOR DX,DX MOV BX,10 ; Preparati per la conversione CICLO:DIV BX ; Dividi AX per 10 ADD DL,'0' ; Converti il resto in ASCII MOV VET[DI],DL ; Scrivilo nel VET INC DI ; Incrementa il contatore XOR DX,DX ; Azzera il registrp





CMP AX,0 ; Confronta il risultato con '0' JNZ CICLO ; Se non Š vero ripeti MOV CX,DI ; Altrimanti copia il contatore DEC DI ; Decrementa i caratteri del numero CICLO1:MOV DL,VET[DI] ; Parti dall'ultimo numero MOV AH,2 INT 21H ; Stampa il numero DEC DI LOOP CICLO1 ; Termina con la stampa delle decine MOV AH,2 ; Vai a capo MOV DL,CR INT 21H MOV DL,LF INT 21H POP CX ; Recupera il contatore del vettore RET SCRIVI ENDP STAMPA PROC NEAR XOR SI,SI ; Azzera il puntatore LEA SI,V1 ; Associa SI al vettore MOV CX,N ; Metti in CX la sua dimensione INIZIO:MOV DX,[SI] ; Prendi il primo elemento CALL SCRIVI ; Scrivilo sul video in decimale ADD SI,2 ; Passa e quello successivo LOOP INIZIO RET STAMPA ENDP MOLTIPLICA PROC NEAR ; Valori di ritorno: PUSH AX ; AX=NUM1 DX=0 (Fine giro 1) PUSH CX ; AX=NUM2 DX=NUM1*10 (Fine giro 2) MOV AX,DX MOV CX,10 MUL CX MOV DX,AX POP CX POP AX RET MOLTIPLICA ENDP .STARTUP CALL LEGGI LEA DX,MES2 MOV AH,9 INT 21H ; Stampa il messaggio 2 CALL STAMPA .EXIT END





legge_n.asm ; Programma che inserisce un numero da tastiera (inserisce una sequenza di ; caratteri ASCII) ed in DX viene messa la sua rappresentazione bimaria .MODEL SMALL .STACK .CODE CR EQU 13 LEGGI PROC NEAR PUSH AX ; Salva il registro AX XOR DX, DX ; Azzera il registro per la lettura INIZIO:MOV AH,1 ; Predisponi la lettura "senza echo" INT 21H ; Leggi il carattere (in AL) CMP AL,CR ; Confrontalo con il "RETURN" JZ FINE ; Se ugulale vai alla FINE CMP AL,'9' ; Confrontalo con il carattere "9" JA INIZIO ; Se (NUM>9) inserisci altro numero CMP AL,'0' ; Confrontalo con il carattere "0" JB INIZIO ; Se (NUM<0) leggi un altro numero SUB AL,'0' ; Ora in AL ho il numero DECIMALE CALL MOLTIPLICA ; AX=NUM1 DX=0*10=0 (alla fine del I giro) ; AX=NUM2 DX=NUM1*10 (alla fine del II giro) XOR AH,AH ; Azzera la parte alta di AX ADD DX,AX ; DX=DX+AX JMP INIZIO ; Ritorna all'inizio FINE:POP AX ; Recupera il valore iniziale di AX RET LEGGI ENDP MOLTIPLICA PROC NEAR PUSH AX PUSH CX MOV AX,DX MOV CX,10 MUL CX MOV DX, AX POP CX POP AX RET MOLTIPLICA ENDP .STARTUP CALL LEGGI .EXIT END





matr_max.asm ; Cerca il maggiore in una matrice e mette in: ; SI = indice di colonna ; DI = indice di riga ; MAX= numero massimo .MODEL SMALL .STACK .DATA RIG EQU 4 COL EQU 5 MAX DB ? MAT DB 64, 63, 63, 65, 66 DB 6, 10, 8, 9, 67 DB 11, 63, 13, 63, 15 DB 20, 21, 22, 23, 91 .CODE .STARTUP XOR SI,SI ; Indice di colonna XOR DI,DI ; Indice di riga MOV CX,RIG*COL XOR AX,AX MOV BX,0 ; Azzera contatore di numeri nella matrice MOV DL,MAT[BX] MOV MAX,DL ; Inizializza il MAX CICLO: MOV AL,MAT[BX] CMP AL,MAX JB PROSSIMO ; Se minore vai al prossimo XCHG AL,MAX ; Scambia PUSH AX ; Salva AX MOV AX,BX ; Salva l'indice in AX (usato per la DIV) PUSH BX ; Salva BX (indice all'elemento) XOR BX,BX ; (serve per azzerare la parte alta) MOV BL,COL DIV BL ; In AH ho il resto (Numero di colonna) ; In AL ho il risultato (Numero di riga) POP BX ; Recupera BX (l'indice) XOR DH,DH ; Azzera la parte alta di DX MOV DL,AH ; Metti l'indice di colonna in DL MOV SI,DX ; Memorizza l'indice di colonna XOR DH,DH ; Azzera la parte alta di DX MOV DL,AL ; Metti l'indice di riga in DL MOV DI,DX ; Memorizza l'indice di riga POP AX ; Recupera AX (l'elemento) XOR AX,AX ; Preparati per il prossimo numero PROSSIMO:INC BX LOOP CICLO .EXIT END





min_max.asm ; trova il massimo ed il minimi di un vettore di numeri senza segno a 16 bit .MODEL SMALL .STACK .DATA DIM EQU 5 ; dimensione del vettore VET DW 1234,23,78,2056,2980 ; Numeri decimali senza segno .CODE CALCOLA PROC NEAR ; Procedura che calcola MIN e MAX XOR SI,SI LEA SI,VET ; Assicia puntatore a WORD MOV BX,[SI] ; BX = vet(1) (VALORE MINIMO) MOV DX,[SI] ; DX = vet(1) (VALORE MASSIMO) MOV CX,DIM ; Inizializza variabile di ciclo CICLO:MOV AX,[SI] CMP AX,BX JA DOPO ; Se VET(SI)>MIN confronta con MAX MOV BX,AX ; altrimanti scambia JMP SUCCESSIVO DOPO: CMP AX,DX JB SUCCESSIVO ; Se VET(SI)<MAX vai a SUCCESSIVO MOV DX,AX ; Altrimenti scambia SUCCESSIVO:ADD SI,2 LOOP CICLO ; Decrementa CX e torna a CICLO RET CALCOLA ENDP .STARTUP CALL CALCOLA .EXIT END





out-vet.asm ; Programma che visualizza un vettore di numeri scritti in decimale e ; sempre in decimale li stampa sul video (interi senza segno) .MODEL SMALL .STACK .DATA CR EQU 13 LF EQU 10 DIM EQU 3 V1 DW 230,235,260 VET DB 5 DUP (?) .CODE SCRIVI PROC NEAR PUSH CX ; Salva il contatore di elementi XOR DI,DI ; Azzera cont. caratteri del numero MOV AX,DX ; Copia l'elemento v(i) in AX XOR DX,DX MOV BX,10 ; Preparati per la conversione CICLO:DIV BX ; Dividi AX per 10 ADD DL,'0' ; Converti il resto in ASCII MOV VET[DI],DL ; Scrivilo nel VET INC DI ; Incrementa il contatore XOR DX,DX ; Azzera il registrp CMP AX,0 ; Confronta il risultato con '0' JNZ CICLO ; Se non Š vero ripeti MOV CX,DI ; Altrimanti copia il contatore DEC DI ; Decrementa i caratteri del numero CICLO1:MOV DL,VET[DI] ; Parti dall'ultimo numero MOV AH,2 INT 21H ; Stampa il numero DEC DI LOOP CICLO1 ; Termina con la stampa delle decine MOV AH,2 ; Vai a capo MOV DL,CR INT 21H MOV DL,LF INT 21H POP CX ; Recupera il contatore del vettore RET SCRIVI ENDP .STARTUP XOR SI,SI ; Azzera il puntatore LEA SI,V1 ; Associa SI al vettore MOV CX,DIM ; Metti in CX la sua dimensione INIZIO:MOV DX,[SI] ; Prendi il primo elemento CALL SCRIVI ; Scrivilo sul video in decimale ADD SI,2 ; Passa e quello successivo LOOP INIZIO .EXIT END





scrive-n.asm ; Progeramma che stampa il contenuto del registro DX (in ESADECIMALE) ; sul video in DECIMALE .MODEL SMALL .STACK .DATA CR EQU 13 LF EQU 10 MES1 DB "Il numero contenuto in DX Š : ","$" VET DB 5 DUP (?) ; Utilizzato per la stampa .CODE STAMPA PROC NEAR PUSH DX ; Salva il numero da stampare XOR DX,DX LEA DX,MES1 MOV AH,9 ; Stampa "Il risultato Š : " INT 21H POP DX ; Riprendi il numero da stampare MOV AX,DX ; Mettilo in AX XOR DI,DI ; Azzera il puntatore XOR DX,DX MOV BX,10 CICLO:DIV BX ADD DL,'0' ; Trasforma in ASCII MOV VET[DI],DL ; Metti il resto nel vettore INC DI XOR DX,DX CMP AX,0 ; Confronta il risultato della DIV con 0 JNZ CICLO ; Se non uguale a zero ripeti MOV CX,DI DEC DI ; Ora DI punta all'ultimo elemento CICLO1:MOV DL,VET[DI] MOV AH,2 ; Predisponi la scrittura su video INT 21H DEC DI LOOP CICLO1 MOV AH,2 MOV DL,CR INT 21H MOV DL,LF INT 21H RET STAMPA ENDP .STARTUP MOV DX,0AAAH CALL STAMPA .EXIT END

Esercizi ASM CeTeM (pdf - 235 KB)

Documents

Transcript of Esercizi ASM CeTeM (pdf - 235 KB)