Anteprima
Vedrai una selezione di 5 pagine su 19
Raccolta Esercizi Assembly Pag. 1 Raccolta Esercizi Assembly Pag. 2
Anteprima di 5 pagg. su 19.
Scarica il documento per vederlo tutto.
Scarica
Raccolta Esercizi Assembly Pag. 6
Anteprima di 5 pagg. su 19.
Scarica il documento per vederlo tutto.
Scarica
Raccolta Esercizi Assembly Pag. 11
Anteprima di 5 pagg. su 19.
Scarica il documento per vederlo tutto.
Scarica
Raccolta Esercizi Assembly Pag. 16
1 su 19
D/illustrazione/soddisfatti o rimborsati
Disdici quando
vuoi
Acquista con carta
o PayPal
Scarica i documenti
tutte le volte che vuoi
Estratto del documento

Programma 1

FINE RTSI DC 4
END START
*FOR i=1 to 60 step 2
D1=!D1+i+contenuto memoria ($8400)
ORG $8000
START MOVEM.L A0/D3,-(SP)
LEA $8420,A0
MOVE #2,(A0)
MOVE #3,D3
JSR PROG
MOVEM.L (SP)+,A0/D3
STOP #$2700
PROG MOVEM.L D0,-(SP)
MOVE I,D0
LOOP CMP #40,D0
BGT FINE
NEG D3
ADD D0,(A0)
ADD (A0),D3
ADD #4,D0
JMP LOOP
FINE MOVEM.L (SP)+,D0
RTSI DC 5
END START

Programma 2

FOR J=0 to 50
J MINORE=20 THEN 8200+J = D3+1
ELSE 8100+J = D3-2
ORG $8000
START MOVEM.L A0-A1/D3,-(SP)
LEA $8200,A0
LEA $8100,A1
MOVE.B #2,D3
JSR PROGR
MOVEM.L (SP)+,A0-A1/D3
STOP #$2700
ORG $8300
PROGR MOVEM.L D0,-(SP)
CLR D0
MOVE J,D0
LOOP CMP #20,D0
BGT ELSE
ADD.B #1,D3
MOVE.B D3,(A0,D0)
JMP TEST
ELSE SUB.B #2,D3
MOVE.B D3,(A1,D0)
TEST ADD.B #1,D0
CMP #50,D0
BLE LOOP
MOVEM.L (SP)+,D0
RTS
ORG $8520
J DC 0
END START

Programma 3

FOR J=5 to 19
Sum=Sum + X(J)°Y(J)
ORG $8000
START MOVEM.L A0-A1/D0,-(SP)
LEA X,A0
LEA Y,A1
MOVE #LEN-1,D0
JSR SOTTOPROGRAMMA
MOVEM.L (SP)+,A0-A1/D0-D1
STOP #$2700
ORG $8200
SOTTOPROGRAMMA MOVEM.L D1-D4,-(SP)
LOOP MOVE 8(A0,D4),D1
MOVE 8(A1,D4),D2
MULU D2,D1
MOVE D1,D3
ADD #2,D4
DBRA D0,LOOP
MOVE

D3,SUMMOVEM.L (SP)+,D1-D4RTSORG $8400LEN EQU 14SUM DS 1X DC 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20Y DC 0,2,4,6,8,10,12,14,16,18,20,1,3,5,7,9,11,13,15,17,19END STARTIFIF $8800 MAGGIORE di 100 THEN $8200 + cont$8422=!D1+D5 ELSE $8220 +cont$8244=D0+!D4ORG $8000START MOVEM.L A0-A3/D0-D5,-(SP)LEA $8800,A0LEA $8220,A1LEA $8422,A2LEA $8244,A3MOVE #98,(A0)MOVE #3,(A2)MOVE #2,(A3)MOVE #2,D0MOVE #3,D1MOVE #2,D4MOVE #4,D5MOVE (A2),D2MOVE (A3),D3JSR PROGMOVEM.L (SP)+,A0-A3/D0-D1/D4-D5STOP #$2700PROG ORG $8500CMP #100,(A0)BLT ELSENEG D1ADD D1,D5MOVE D5,(A1,D2)JMP FINEELSE NEG D4ADD D4,D0MOVE D0,(A1,D3)FINE RTSEND START*IF bit 3 di X=1*THEN (locazione di memoria ($8202 + contenuto della locazione $8110))=D0 * D3*ELSE (locazione di memoria ($8110 + contenuto della locazione $8202))=D1 OR D4ORG $8000START MOVEM.L A0-A1/D0-D5,-(SP)LEA $8202,A0LEA $8110,A1MOVE #1,D0MOVE #2,D1MOVE #3,D3MOVE #4,D4MOVE #1,(A0)MOVE #2,(A1)MOVE X,D5JSR PROGMOVEM.L (SP)+,A0-A1/D0-D5STOP #$2700ORG $8300PROG

MOVEM.L A0-A1/D0-D5,-(SP)
BTST #3,D5
BEQ ELSE
MULU D3,D0
MOVE D0,(A0,A1)
JMP FINE
ELSE
OR D4,D1
MOVE D1,(A1,A0)
FINE
MOVEM.L (SP)+,A0-A1/D0-D5
RTS

ORG $8400
X DC 8
END START

*IF bit 4 D1 =0
*then decrementa contenuto di memoria ($8208 + contenuto della locazione $8406)
*else incrementa contenuto di memoria ($8208 + contenuto della locazione $8604)

ORG $8000
START MOVEM.L A0-A2/D1,-(SP)
LEA $8208,A0
LEA $8406,A1
LEA $8604,A2
MOVE #1,(A0)
MOVE #2,(A1)
MOVE #3,(A2)
MOVE #2,D1
JSR PROGRAMMA
MOVEM.L (SP)+,A0-A2/D1
STOP #$2700

ORG $8400
PROGRAMMA MOVEM.L D0,-(SP)
BTST #2,D1
BNE ELSE
MOVE (A1),D0
SUB #1,(A0,D0)
JMP FINE
ELSE
MOVE (A2),D0
ADD #1,(A0,D0)
FINE MOVEM.L (SP)+,D0
RTS

END START

*IF bit 4 di X=0
*THEN (locazione di memoria ($8700 + D1 * 3))=!D0 + 20
*ELSE (locazione di memoria ($8200 + D1 *2))=D1 - 30

ORG $8000
START MOVEM.L A0-A1/D0-D1,-(SP)
LEA $8200,A0
LEA $8700,A1
MOVE #2,D0
MOVE #40,D1
MOVE X,D2
JSR PROGR
MOVEM.L (SP)+,A0-A1/D0-D1
STOP #$2700

PROGR MOVEM.L D2-D3,-(SP)
BTST #4,D2
BNE ELSE
NEG D0
ADD #20,D0
MULU #3,D1
MOVE D0,(A1,D1)
JMP
ATTENZIONE: non modificare il testo in altro modo, NON aggiungere commenti, NON utilizzare tag h1;

FINELSE MOVE D1,D3
SUB #30,D3
MULU #2,D1
MOVE D3,(A0,D1)
FINEMOVEM.L (SP)+,D2-D3
RTS

ORG $8500
X DC 8
END START

*IF bit 5 di D5=1
*THEN $8700+D1=D0+2
*ELSE $8200+D0=D1+3

ORG $8000
START MOVEM.L A0-A1/D0-D1,-(SP)
LEA $8700,A0
LEA $8200,A1
MOVE.B #2,D0
MOVE.B #3,D1
JSR PROG
MOVEM.L (SP)+,A0-A1/D0-D1
STOP #$2700

ORG $8400
PROG MOVEM.L D5,-(SP)
MOVE.B #8,D5
BTST #5,D5
BEQ ELSE
ADD.B #2,D0
MOVE.B D0,(A0,D1)
JMP FINE
ELSE ADD.B #3,D1
MOVE.B D1,(A1,D0)
FINE MOVEM.L (SP)+,D5
RTS

END START

IF con INDICE=8 THEN 8100=0 - ELSE 8100=1 - OK

ORG $8000
START MOVEM.L A0,-(SP)
LEA $8100,A0
JSR IF_INDICE
MOVEM.L (SP)+,A0
STOP #$2700

ORG $8200
IF_INDICE CMP #8,INDICE
BNE ELSE
MOVE #0,(A0)
JMP FINE
ELSE MOVE #1,(A0)
FINE RTS

ORG $8400
INDICE DC 3
END START

*IF D0 != 150
*THEN (locazione di memoria $8800)=D5 + !(contenuto della locazione $8504)
*ELSE (locazione di memoria $8600)=D6 + !(contenuto della locazione $8202)

ORG $8000
START MOVEM.L A0-A3/D5-D6,-(SP)
LEA $8800,A0
LEA $8600,A1
LEA $8504,A2
LEA $8202,A3
MOVE #3,(A2)
MOVE #2,(A3)
MOVE #3,D5
MOVE #4,D6
JSR
PROGMOVEM.L (SP)+,A0-A3/D5-D6
STOP #$2700

PROG MOVEM.L D0,-(SP)
MOVE #151,D0
CMP #150,D0
BEQ ELSE
NEG (A2)
ADD (A2),D5
MOVE D5,(A0)
JMP FINE
ELSE
NEG (A3)
ADD (A3),D6
MOVE D6,(A1)
FINE MOVEM.L (SP)+,D0
RTS

END START

IF i=1 to $8600 D0=!D0+$8500 - OK
ORG $8000

START MOVEM.L A0-A1/D0-D1,-(SP)
LEA $8500,A0
LEA $8600,A1
MOVE #3,(A0)
MOVE #8,(A1)
MOVE INDICE,D1
MOVE #4,D0
JSR PROGMOVEM.L (SP)+,A0-A1/D0-D1
STOP #$2700

ORG $8200

PROG MOVEM.L A0-A1/D0-D1,-(SP)
NEG D0
LOOP CMP (A1),D1
BGE FINE
ADD (A0),D0
ADD #1,D1
JMP LOOP
FINE MOVEM.L (SP)+,A0-A1/D0-D1
RTS

ORG $8400

INDICE DC 1

END START

IF Indice !=100 THEN $8104=D5 OR MASK ELSE $8204=D5 AND MASK
ORG $8000

START MOVEM.L A0-A1/D3-D5,-(SP)
LEA $8104,A0
LEA $8204,A1
MOVE #3,D5
MOVE MASK,D4
MOVE INDICE,D3
JSR PROGMOVEM.L (SP)+,A0-A1/D3,D5
STOP #$2700

PROG CMP #100,D3
BEQ ELSE
OR D5,D4
MOVE D4,(A0)
JMP FINE
ELSE
AND D5,D4
MOVE D4,(A1)
FINE RTS

MASK DC $FF
INDICE DC 100

END START

*IF indice ==12
*THEN (locazione di memoria ($8200 + indice))=D3- 1
*ELSE (locazione di memoria ($8100 + indice))=D3*2

ORG
```html


$8000START MOVEM.L A0-A1/D3,-(SP)LEA $8200,A0LEA $8100,A1MOVE.B #4,(A0)MOVE.B #3,(A1)MOVE.B #2,D3JSR PROGMOVEM.L (SP)+,A0-A1/D3STOP #$2700PROG MOVEM.L D0,-(SP)MOVE.B INDICE,D0CMP #12,D0BNE ELSESUB.B #1,D3MOVE.B D3,(A0,D0)JMP FINEELSE MULU #2,D3MOVE.B D3,(A1,D0)FINE MOVEM.L (SP)+,D0RTSORG $8400INDICE DC 5END START*IF Indice > 25*THEN locazione $8300+Indice=D2+1*ELSE locazione $8200+Indice=D2-2ORG $8000START MOVEM.L A0-A1/D2,-(SP)LEA $8300,A0LEA $8200,A1MOVE #3,D2JSR PROGMOVEM.L (SP)+,A0-A1/D2STOP #$2700PROG MOVEM.L D0,-(SP)MOVE INDICE,D0CMP #25,D0BLT ELSEADD #1,D2MOVE D2,(A0,D0)JMP FINEELSE SUB #2,D2MOVE D2,(A1,D0)FINE MOVEM.L (SP)+,D0RTSORG $8400INDICE DC 22END START*IF indice >=20*THEN (locazione di memoria ($8200 + contenuto della locazione $8210))=3 * !D2*ELSE (locazione di memoria ($8400 + contenuto della locazione $8220))= 2 * !D1ORG $8000START MOVEM.L A0-A3/D0-D2,-(SP)LEA $8200,A0LEA $8400,A1LEA $8210,A2LEA $8220,A3MOVE #2,(A2)MOVE #2,(A3)MOVE #2,D1MOVE #2,D2MOVE I,D0JSR



```

PROGMOVEM.L (SP)+,A0-A3/D0-D2
STOP #$2700
ORG $8500
PROG MOVEM.L D3,-(SP)
CMP #20,D0
BLT ELSE
NEG D2
MULU #3,D2
MOVE (A2),D3
MOVE D2,(A0,D3)
JMP FINE
ELSE
NEG D1
MULU #2,D1
MOVE (A3),D3
MOVE D1,(A1,D3)
FINE MOVEM.L (SP)+,D3
RTS
ORG $8800
I DC 5
END START
*IF indice <30
*THEN (locazione di memoria $8320)=!D2 + X
*ELSE (locazione di memoria $8606)=D2 * !Y
ORG $8000
START MOVEM.L A0-A1/D2,-(SP)
LEA $8320,A0
LEA $8606,A1
MOVE #2,D2
JSR PROG
MOVEM.L (SP)+,A0-A1/D2
STOP #$2700
ORG $8200
PROG MOVEM.L D0-D1,-(SP)
MOVE INDICE,D0
CMP #30,D0
BGT ELSE
NEG D2
MOVE Y,D1
ADD D1,D2
MOVE D2,(A0)
JMP FINE
ELSE
MOVE Y,D1
NEG D1
MULU D1,D2
MOVE D2,(A1)
FINE MOVEM.L (SP)+,D0-D1
RTS
ORG $8400
X DC 2
Y DC 5
INDICE DC 28
END START
*IF Indice pari
*THEN (locazione di memoria ($8600 + indice))=contenuto della locazione $8400
*ELSE (locazione di memoria ($8600 - indice))=contenuto della locazione $8400
ORG $8000
START MOVEM.L A0-A1/D0,-(SP)
LEA $8600,A0
LEA $8400,A1
MOVE #9,(A0)
MOVE #5,(A1)
MOVE INDICE,D0
JSR COSTRUTTO
MOVEM.L (SP)+,A0-A1/D0
STOP #$2700


```html

$8200COSTRUTTO MOVEM.L D1,-(SP)
BTST #0,D0
BNE ELSE
MOVE (A1),(A0,D0)
JMP FINE
ELSE SUB D0,(A0)
MOVE (A1),(A0)
FINE MOVEM.L (SP)+,D1
RTS

ORG $8500
INDICE DC 5
END START

IF Q=4 - THEN X=5 - ELSE X=Y - OK

ORG $8000
START MOVEM.L D0,-(SP)
MOVE Q,D0
JSR COSTRUTTO
MOVEM.L (SP)+,D0
STOP #$2700

ORG $8200
COSTRUTTO MOVEM.L D1,-(SP)
CMP #4,D0
BNE ELSE
MOVE #5,D1
MOVE D1,X
JMP FINE
ELSE MOVE Y,D1
MOVE D1,X
FINE MOVEM.L (SP)+,D1
RTS

ORG $8400
Q DC 4
Y DC 8
X DS 1
END START

SOMMA
Conta quanti numeri DISPARI ci sono MAGGIORI di 20 e MINORI di 55 tra
$810F e $811C - (ESAME)

ORG $8000
START MOVEM.L A0-A1,-(SP)
LEA $810F,A0
LEA $811C,A1
JSR PROG
MOVEM.L (SP)+,A0-A1
STOP #$2700

PROG MOVEM.L D0-D1,-(SP)
LOOP MOVE.B (A0)+,D0
BTST #0,D0
BEQ CONTROLLO
CMP #20,D0
BLT CONTROLLO
CMP #55,D0
BGT CONTROLLO
LOADD.B #1,D1
CONTROLLO CMP.L A0,A1
BNE LOOP
MOVEM.L (SP)+,D0-D1
RTS

ORG $810F
X DC.B 12,18,45,33,28,56,45,34,26,47,34,22,21,12,42,54,62,79,23,21,52
END START

Conta quanti numeri PARI ci sono MAGGIORI di D0 e MINORI = di D1 tra $811F e $813E

ORG $8000
START MOVEM.L


```
A0-A1/D0-D1,-(SP)
LEA $811F,A0
LEA $813E,A1
MOVE.B #10,D0
MOVE.B #20,D1
JSR PROG
MOVEM.L (SP)+,A0-A1/D0-D1
STOP #$2700

PROG
MOVEM.L D2-D3,-(SP)
LOOP
MOVE.B (A0)+,D2
Dettagli
Publisher
enzonapoli1996
A.A. 2022-2023
19 pagine
SSD Scienze matematiche e informatiche INF/01 Informatica
I contenuti di questa pagina costituiscono rielaborazioni personali del Publisher enzonapoli1996 di informazioni apprese con la frequenza delle lezioni di architettura dei calcolatori e studio autonomo di eventuali libri di riferimento in preparazione dell'esame finale o della tesi. Non devono intendersi come materiale ufficiale dell'università Università degli Studi di Napoli - Parthenope o del prof Salvi Giuseppe.