Università degli Studi di Napoli Federico II Facoltà di Ingegneria

Corso di Calcolatori Elettronici I A.A. 2010-2011

Introduzione alla programmazione assembly

Lezione 21

Organizzazione Motorola 68000 Program Counter (PC) 32 Effective Address Register (EAR) 32

Memory and I/O Interface Control Pipeline

General Registers D0..D7 A0..A6 A7= User Stack pointer (USP) A7’=Supervisor Stack Pointer(SSP)

Temporary Register 32 32

Instruction Register(IR) 16

Instruction Decode and Control

Arithmetic and Logic Unit (ALU)

32

CCR SR

8

External Bus

Internal Bus

Holds address of the next instruction to be executed

If necessary Holds the address of memory reads/writes

Holds first word of currently executing instruction

Holds operands or intermediate results

Performs all logical or arithmetic operations ( ADD, SHIFT, etc. ) Holds result of ALU

Operations

Modello di programmazione del MC68000

31 16 15 8 7 0 D0 D1 D2 D3 D4 D5 D6 D7

A0 A1 A2 A3 A4 A5 A6 A7 PC SR T S I2 I1 I0 C V Z N X

Ø Contiene:

Ø La interrupt mask (8 livelli)

Ø I codici di condizione (CC) - oVerflow (V), Zero (Z), Negative (N), Carry (C), e eXtend (X)

Ø Altri bit di stato - Trace (T), Supervisor (S)

Ø I Bits 5, 6, 7, 11, 12, e 14 non sono definiti e sono riservati per espansioni future

Status register

Esempio di generazione di codice assemblato

PLC contenuto label opcode operands 00000000 1 * Un commento non fa incrementare il PLC 00002000 2 ORG $2000 00002000 4279 2032 3 START CLR.W SUM Riferimento in avanti 00002006 3039 2034 4 MOVE.W ICNT,D0 0000200C 33C0 2030 5 ALOOP MOVE.W D0,CNT 00002012 D079 2032 6 ADD.W SUM,D0 00002018 33C0 2032 7 MOVE.W D0,SUM 0000201E 3039 2030 8 MOVE.W CNT,D0 00002024 0640 FFFF 9 ADD.W #-1,D0 00002028 66E2 10 BNE ALOOP 0000202A 4EF9 8008 11 JMP SYSA 00002030 =8008 12 SYSA EQU $8008 00002030 13 CNT DS.W 1 00002032 14 SUM DS.W 1 00002034 =0011 15 IVAL EQU 17 00002034 0011 16 ICNT DC.W IVAL

comments

ALOOP 200C CNT 2030 IVAL 0011 START 2000 SUM 2032 ICNT 2034

Symbol Table

Formato delle istruzioni assembly

•  Le istruzioni assembly sono tipicamente costituite da un codice mnemonico seguito da uno o più operandi.

•  Ad esempio, le istruzioni a due operandi per il trasferimento e le operazioni aritmetiche sui dati sono tipicamente nella forma:

Operazione Sorgente,Destinazione

•  Per esempio, per effettuare la somma tra due numeri si potrà scrivere: ADD A,B

•  Questo comando realizza la somma di A e B e porrà il risultato dell’operazione in B sovrascrivendone il contenuto corrente.

Formato Istruzioni del 68000

•  La prima word di una istruzione è chiamataOpcode word –  Tuute le informazioni necessarie per decodificare un’istruzione

sono nell’ Opcode Word –  Contiene un opcode (cosa fa) –  Contiene zero,uno o due effective address fields (EA)

•  L’istruzione completa in memoria può contenere l’ opcode word ed altre word di istruzioni addizionali –  Un’istruzione può richiedere fino a 5 word di memoria

•  La forma generale della istruzione assembly è la seguente:

Label OP CODE sorgente, destinazione *Comment

Esempio: l’istruzione MOVE

•  Volendo realizzare una copia del contenuto di un registro in un altro, ad esempio, il linguaggio assembly potrebbe richiedere di scrivere:

MOVE R0,SOMMA

•  Il codice mnenonico, in questo caso MOVE, rappresenta l’azione svolta dall’istruzione.

•  L’assemblatore traduce questo codice mnemonico in un codice binario di forma comprensibile al calcolatore, di solito chiamato codice operativo (OP-CODE).

•  Segue almeno uno spazio bianco dopo il quale sono riportate le informazioni che specificano gli operandi.

MOVE (MOVE) •  L’istruzione più comunemente usata per il movimento dati è

MOVE •  Muove - Copia da una sorgente a una destinazione

MOVE [sorgente], [Destinazione]

•  Esempio

MOVE.W D2, $1300 •  copia il contenuto del registro D2 nell'area di memoria di

indirizzo esadecimale 1300

L’istruzione MOVE •  Istruzioni di movimento dati tipiche del 68000 sono:

MOVE Di, Dj MOVE M, Di

MOVE Di, M

MOVEA - utilizza semre registri indirizzi come destinazione e non impatta lo Status Register

MOVEQ - (quick move) utilizzata per il movimento di valori piccoli (fino a

8 bits, i.e. -127 to +127) nei registri dati (e.g. MOVEQ.B #3,D3)

Operazioni Aritmetiche Operazioni aritmetiche duali operazione sorgente, destinatario che tipicamente funziona come segue:

destinatario ? sorgente → destinatario dove ? È una delle operazioni aritmetiche (+,-,* or /) e.g.

ADD D0,D1 D1 + D0 → D1

SUB D0,D1 D1 - D0 → D1

MUL D0,D1 D1 * D0 → D1

DIV D0,D1 D1 / D0 → D1

ADD (ADD) •  Aggiungi - Aggiunge un valore a una destinazione

ADD [valore], [Destinazione]

•  Esempio

ADD D1, SOMMA •  aggiunge il contenuto del registro D1 nella variabile di

memoria SOMMA

Gli operandi •  Nel nostro esempio, l’operando sorgente è nel registro D1.

•  Questa informazione è seguita dall’indicazione dell’operando destinazione, separato da quello sorgente attraverso una virgola.

•  L’operando destinazione è nella locazione di memoria il cui indirizzo è rappresentato dal nome simbolico SOMMA.

•  Per creare questa associazione, ogni nome deve essere opportunamente definito nell’ambito del listato creando così un’associazione SIMBOLO -> INDIRIZZO.

Natura degli operandi

•  Gli operandi forniti come argomento di un’istruzione possono contenere informazioni di tipo differente.

•  Può accadere che l’operando contenga direttamente il valore utile per il calcolo. In questo caso si parla di operando immediato ed esso è direttamente codificato di seguito all’istruzione.

•  In altri casi l’operando contiene il riferimento ad un registro del processore il quale può contenere, a sua volta, il dato o (ancora) l’indirizzo di un registro della memoria in cui è contenuto il dato.

Natura degli operandi: esempio.

•  Nell’istruzione ADD #9,D0

il primo operando è di tipo immediato. Il suo valore viene codificato in memoria direttamente assieme all’istruzione. Il secondo operando è un registro interno del processore.

•  Nell’istruzione ADD D0,D1

entrambi gli operandi sono riferimenti a registri interni.

•  L’istruzione ADD D0,#9

è priva di senso dal momento che l’operando destinazione non specifica una locazione di memoria in cui porre il risultato dell’operazione.

Esempio: la somma di due registri

•  Supponiamo di voler realizzare l’istruzione C++

C = A + B;

•  Questa istruzione ha lo scopo di sommare il contenuto delle locazioni di memoria individuate dagli identificatori A e B e, successivamente, di porre il risultato della somma nella locazione di memoria individuata dall’identificatore C.

•  Se il linguaggio assembly rende disponibile esclusivamente un’istruzione per la somma a due operandi (come in genere accade), non è possibile realizzare l’elaborazione in un unico passo, ma bisognerà scrivere:

MOVE B,C ADD A,C

Registri interni e memoria (1)

•  Un’istruzione, in generale, può coinvolgere sia i registri interni che i registri della memoria.

•  L’accesso ai registri interni è molto più veloce dell’accesso ai registri della memoria, poiché i primi sono già all’interno del processore e non sorge dunque la necessità di trasferimenti attraverso canali esterni.

•  Inoltre, i registri interni sono in numero molto minore delle celle di memoria (tipicamente da 8 a 64) e quindi per essere indirizzati c’è bisogno di pochi bit.

Registri interni e memoria (2)

•  Ad esempio, un processore che abbia 32 registri interni, può indirizzarli utilizzando 5 bit.

•  Poiché l’uso di registri interni permette elaborazioni più rapide e produce istruzioni più corte, essi sono usati per memorizzare dati temporanei nella CPU durante l’elaborazione.

•  In alcuni casi, determinati comandi assembler possono operare esclusivamente su registri interni; operazioni su registri di memoria non sono ammesse e, su necessità, bisogna esplicitamente provvedere al trasferimento dei dati tra la memoria e i registri interni.

Esempio: codifica di un’istruzione (1)

•  • A titolo esemplificativo prendiamo in considerazione l’istruzione ADD #9,D3

•  che che ha come effetto la somma di 910 al contenuto del registro D3 e la memorizzazione del risultato di nuovo in D3.

•  Nel caso del M68000:

– il comando “ADD da sorgente a registro dati” si codifica con 1101---0------ – L’indice del registro si codifica con ----011--------- – La modalità “operando immediato” si codifica con ----------111100 – La dimensione dell’operando (di default word) si codifica con: --------01------

•  La stringa completa dà: 11010110011111002 = D67C16

Esempio: codifica di un’istruzione (2)

•  L’assembler 68000 permette di specificare il tipo di dato a cui si sta facendo riferimento, aggiungendo un suffisso allo mnemonico del’istruzione:

.B per dati di tipo byte .W per dati di tipo word .L per dati di tipo long.

•  Esempio: MOVE.W DO, D1

Pseudo-operatori

Viene usato per inizializzare il Program Location Counter (PLC) Sintassi:

ORG $HEXADDR es. ORG $1000

END

Viene usato per terminare il processo di assemblaggio e saltare all’entry point del programma Sintassi:

END TARGETLAB

ORG (Origin)

Altri pseudo-operatori

DS (Define Space) •  Viene usato per incrementare il Program Location Counter (PLC), in modo da

riservare spazio di memoria per una variabile •  Sintassi: LABEL DS.W NUMSKIPS •  Esempio TOP DS.B 10 * ho assegnato 10 byte per TOP DC (Define Constant) •  Viene usato per inizializzare il valore di una variabile •  Sintassi: LABEL DC.W VALUE •  Esempio PLUTO DS.B 10 * ho assegnato 10 a PLUTO

EQU (Equate) •  Viene usato per stabilire un’identità •  Sintassi: LABEL EQU VALUE •  Esempio PIPPO EQU 1234 ; Ogni volta che uso #PIPPO in un istruzione equivale

a usare il valore 1234

Operatione: [destinazione] - [sorgente] Sintassi: CMP <ea>,Dn Esempio: CMP (Test,A6,D3.W),D2 Attributi: Size = byte, word, longword Descrizione: Sottrae l’operando sorgente da quello destinatario e setta i condition codes in accordo con il risultato.. Condition codes: X N Z V C - * * * *

CMP Compare

Operation: [destination] - [source] Syntax: CMPM (Ay)+,(Ax)+ Attributes: Size = byte, word, longword Description: Subtract the source operand from the destination operand and set the condition codes accordingly. The destination is not modified by this instruction. The only permitted addressing mode is address register indirect with post-incrementing for both source and destination operands. Application: Used to compare the contents of two blocks of memory. Condition codes:

X N Z V C - * * * *

CMPM Compare memory with memory

Operation: [destination] ← [destination] - <literal> Syntax: SUBQ #<data>,<ea> Attributes: Size = byte, word, longword Description: Subtract the immediate data from the destination operand. The immediate data must be in the range 1 to 8. Word and longword operations on address registers do not affect condition codes. A word operation on an address register affects the entire 32-bit address. Condition codes:

X N Z V C * * * * *

SUBQ Subtract quick

Istruzione di salto (BRA instruction) BRA <label> Il controllo del programma passa direttamente alla istruzione individuata dalla label. L’ampiezza del salto è limitata a -32768 to +32767. Esempio: loop <instruction> . . . BRA loop

L’istruzione JMP

Salto Condizionale (Conditional branching) L’ istruzione Bcc (branch on condition)

Il salto viene eseguito in dipendenza dello stato dei flag nello status register (SR)

X N Z V C

status flags

•  Lo status Register è Sempre interessato dalla istruzione del programma appena eseguita

Salto Condizionale (Conditional branching)

L’ istruzione Bcc (branch on condition)

cc - condition code CC carry clear CCS carry set

EQ equal ZNE not equal Z

C(salta se carry bit è clear, i.e. 0) (salta se carry bit è settato, i.e. 1) (salta se zero bit è clear, i.e. 0) (salta se zero bit è settato, i.e. 1)

Salto Condizionale (Conditional branching)

Altri condition codes PL plus NMI minus N

LE less or equal VNVNZ ⋅+⋅+

GT greater than ZVNZVN ⋅⋅+⋅⋅

Istruzioni di selezione in assembler – 1/2

Linguaggio di alto livello:

if (espressione) istruzione

istruzione_successiva

NOTA: istruzione può essere un compound statement

Linguaggio assembler (processore MC 68000):

B(NOT condizione) labelA istruzione ...

labelA istruzione_successiva

Esempio:

CMPI.L #5,D0 if (D0 == 5) BNE SKIP

D1++; ADDQ.L #1,D1 D2 = D0; SKIP MOVE.L D0,D2

Istruzioni di selezione in assembler – 2/2

Linguaggio di alto livello:

if (espressione) istruzione1

else istruzione2

istruzione_successiva

Linguaggio assembler (processore MC 68000):

B(NOT condizione) labelA istruzione1 ... BRA labelB

labelA istruzione2 ...

labelB istruzione_successiva

Strutture iterative in assembler - 1/2

Linguaggio di alto livello:

do istruzione

while (condizione == TRUE); istruzione_successiva

Linguaggio assembler (processore MC 68000):

labelA istruzione ... Bcc labelA istruzione_successiva

Esempio: calcola 3^N (N>0) MOVE.B #N,D2 D0 = 1; D1 = 1; MOVE.B #1,D1 do { MOVE.W #1,D0

D0 = D0 * 3; LOOP MULU.W #3,D0 D1++; ADDQ.B #1,D1

} while (D1 <= N); CMP.B D2,D1 BLE LOOP

Strutture iterative in assembler - 2/2

Linguaggio di alto livello:

while (condizione == TRUE) istruzione;

istruzione_successiva

Linguaggio assembler (processore MC 68000):

BRA labelB labelA istruzione

... labelB Bcc labelA

istruzione_successiva

Esempio: calcola 3^N (N>=0) MOVE.B #N,D2 D0 = 1; D1 = 1; MOVE.B #1,D1 while (D1 <= N) { MOVE.W #1,D0

D0 = D0 * 3; BRA TEST D1++; LOOP MULU.W #3,D0

}; ADDQ.B #1,D1 TEST CMP.B D2,D1 BLE LOOP

Decrement and Branch always (DBRA)

DBRA equivale a DBF: caso particolare di DBcc con cc=FALSE

Esempio: equivale a: MOVE.L #N,D1 MOVE.L #N,D1 SUBQ.L #1,D1 SUBQ.L #1,D1 MOVEA.L #NUM,A2 MOVEA.L #NUM,A2 CLR.L D0 CLR.L D0

LOOP ADD.W (A2)+,D0 LOOP ADD.W (A2)+,D0 DBRA D1,LOOP SUBQ #1,D1 MOVE.L D0,SOMMA BGE LOOP MOVE.L D0,SOMMA

Esempio di generazione di codice assemblato

PLC contenuto label opcode operands 00000000 1 * Un commento non fa incrementare il PLC 00002000 2 ORG $2000 00002000 4279 2032 3 START CLR.W SUM Riferimento in avanti 00002006 3039 2034 4 MOVE.W ICNT,D0 0000200C 33C0 2030 5 ALOOP MOVE.W D0,CNT 00002012 D079 2032 6 ADD.W SUM,D0 00002018 33C0 2032 7 MOVE.W D0,SUM 0000201E 3039 2030 8 MOVE.W CNT,D0 00002024 0640 FFFF 9 ADD.W #-1,D0 00002028 66E2 10 BNE ALOOP 0000202A 4EF9 8008 11 JMP SYSA 00002030 =8008 12 SYSA EQU $8008 00002030 13 CNT DS.W 1 00002032 14 SUM DS.W 1 00002034 =0011 15 IVAL EQU 17 00002034 0011 16 ICNT DC.W IVAL

comments

ALOOP 200C CNT 2030 IVAL 0011 START 2000 SUM 2032 ICNT 2034

Symbol Table

Link ASIM

•  http://digilander.libero.it/rosario.cerbone/Asim.htm

Esempio esito del confronto

$FF è maggiore di $10 se i numeri sono interpretati come unsigned, in quanto 255 è maggiore di 16 Tuttavia se i numeri sono interpretati come signed, $FF è minore di $10, in quanto -1 è minore di 16.

IL PROCESSORE NON TIENE CONTO DEL TIPO DI RAPPRESENTAZIONE QUANDO SETTA I FLAG DI CONDIZIONE

Esempio - Moltiplicazione di due interi

* Programma per moltiplicare MCND e MPY * ORG $8000 * MULT CLR.W D0 D0 accumula il risultato MOVE.W MPY,D1 D1 e' il contatatore di ciclo BEQ DONE Se il contatore e' zero e' finito LOOP ADD.W MCND,D0 Aggiunge MCND al prodotto parziale ADD.W #-1,D1 Decrementa il contatore BNE LOOP e ripete il giro DONE MOVE.W D0,PROD Salva il risultato PROD DS.W 1 Riserva spazio di memoria per PROD MPY DC.W 3 Definisce il valore di MPY MCND DC.W 4 Definisce il valore di MCND END MULT Fine ass., salto a entry point

Esercitazione

•  Scrivere ed assemblare un programma che moltiplichi due interi

•  Eseguire il programma sul simulatore e sperimentare: –  L’effetto di DC e la rappresentazione esadecimale in memoria –  L’effetto dell’istruzione CLR su registro –  L’effetto dell’istruzione MOVE da memoria a registro –  L’effetto dell’istruzione BEQ sul PC –  L’effetto dell’istruzione ADD tra memoria e registro –  L’effetto dell’istruzione ADD tra immediato e registro –  L’effetto dell’istruzione BNE sul PC –  L’effetto dell’istruzione JMP sul PC –  L’effetto dell’istruzione MOVE da registro a memoria e la

rappresentazione esadecimale in memoria

Soluzione – mult2ints.a68

ORG $8000 MULT CLR.W D0 D0 accumula il risultato MOVE.W MPY,D1 D1 e' il contatatore di ciclo BEQ DONE Se il contatore e' zero e' finito LOOP ADD.W MCND,D0 Aggiunge MCND al prodotto parziale ADD.W #-1,D1 Decrementa il contatore BNE LOOP e ripete il giro DONE MOVE.W D0,PROD Salva il risultato PROD DS.W 1 Riserva spazio di memoria per PROD MPY DC.W 3 Definisce il valore di MPY MCND DC.W 4 Definisce il valore di MCND END MULT Fine ass., salto a entry point

68kasm.exe -l filename.a68 o in alternativa: assembla.bat

Soluzione - Assemblaggio

Soluzione - Esecuzione

Esercitazione

DONE MOVE.W D0,PROD Salva il risultato PROD DS.W 1 Riserva spazio di memoria per PROD

•  Nell’esempio precedente, effettuare le seguenti sostituzioni ed osservarne gli effetti

DONE MOVE.L D0,PROD Salva il risultato PROD DS.L 1 Riserva spazio di memoria per PROD

Esempio - Somma di n interi

START CLR.W SUM MOVE.W ICNT,D0

ALOOP MOVE.W D0,CNT ADD.W SUM,D0 MOVE.W D0,SUM MOVE.W CNT,D0 ADD.W #-1,D0 BNE ALOOP CNT DS.W 1 SUM DS.W 1 IVAL EQU 17 ICNT DC.W IVAL END START

Esercitazione

•  Scrivere un programma che sommi i primi n interi •  Assemblare ed eseguire il programma sul

simulatore •  Sperimentare:

–  L’effetto dell’istruzione CLR in memoria –  L’effetto dell’istruzione MOVE da memoria a registro –  L’effetto dell’istruzione ADD tra memoria e registro –  L’effetto delle varie istruzioni sui codici di condizione –  L’effetto dell’istruzione BNE sul PC –  L’effetto dell’istruzione JMP sul PC

Soluzione - sumnnums.a68

START CLR.W SUM MOVE.W ICNT,D0

ALOOP MOVE.W D0,CNT ADD.W SUM,D0 MOVE.W D0,SUM MOVE.W CNT,D0 ADD.W #-1,D0 BNE ALOOP JMP SYSA SYSA EQU $8008 CNT DS.W 1 SUM DS.W 1 IVAL EQU 17 ICNT DC.W IVAL

Esercitazione

•  Scrivere un programma che esegua il prodotto scalare tra due vettori di interi

•  Assemblare ed eseguire il programma sul simulatore

ORG $8000 START MOVE.L #A,A0

MOVE.L #B,A1 MOVE.L #N,D0 SUBQ #1,D0 CLR D2

LOOP MOVE (A0)+,D1 MULS (A1)+,D1 ADD D1,D2 DBRA D0,LOOP MOVE D2,C

DONE JMP DONE N EQU $000A

ORG $80B0 A DC.W 1,1,1,1,1,1,1,1,1,1

ORG $80D0 B DC.W 1,1,1,1,1,1,1,1,1,1 C DS.L 1

Soluzione – scalprod.a68

Memoria – scalprod.a68

A = 80B0

B = 80D0

VETTORE A

VETTORE B

START = 8000 CODICE

Esercitazione

•  Scrivere un programma che: – Riconosca un token in una stringa – Ne memorizzi l’indirizzo in una locazione di

memoria •  Assemblare ed eseguire il programma sul

simulatore

Soluzione – token.a68

ORG $8000 START MOVEA.L #STRING,A0

MOVE.B #TOKEN,D0 LOOP CMP.B (A0)+,D0

BNE LOOP FOUND SUBQ.L #1,A0

MOVE.L A0,TOKENA

ORG $8100 TOKEN EQU ':' STRING DC.B 'QUI QUO:QUA' TOKENA DS.L 1