Appunti Calcolatori elettronici - seconda parte

Per preservare il valore letto dalla memoria e salvato nel registro utilizzo l'estensione del segno. Facendo ciò non cambio il significato del numero ma semplicemente estendo la sua rappresentazione da 1 Byte a 4 Byte.

Importante:

Ho due tipi di istruzioni per Load Byte:

• (1°) Load Byte → Tratto il numero con segno, eseguo l'estensione del segno.
• (2°) Load Byte unsigned → Tratto il numero senza segno, riempio i 3 byte restanti con soli zeri.

Nota:

I caratteri ASCII non hanno segno!!!

Questo problema del riempimento lo ho solo con le istruzioni di Load e non le ho nel caso di istruzioni di Store.

Load (memoria 1Byte) → (registro 4Byte)

Store (registro 4Byte) → (memoria 1Byte)

Posiziono solo il byte meno significativo.

Esempio:

(Programma per copiare una stringa)

Nota:

Indirizzo stringa X = $00

Indirizzo Y = $03

i = $0c

Strcpy:

addi $sp, $sp, -4

sw $t0, 0($sp)

L3:

add $s0, $zero, $zero

add $t4, $a1, $a0, $s0

lb $t2, 0($t1)

add $t3, $s0, $s0, $s0

sb $t2, 0($t3)

addi $s0, $s0, 1

bne $t2, $zero, L3

lw $t0, 0($sp)

addi $sp, $sp, 4

jr $ra

Nota:

Salvo val iniziale di i nello stack.

Inizializzo i: 0

$t4 = ind Y[i]

$t2 = Y[i]

$t3 = ind X[i]

$t3 = X[i] = $t2 = Y[i]

Eseguo la copia

Se $t2 + 0, salto a L3

seno proseguo

Ripristino dati originali

torno al main program

Nota:

Il carattere zero è il terminatore della stringa. Quando lo raggiungo ho terminato il programma.

Costanti:

Nel 50% dei casi le costanti vengono usate come operando. Per questo motivo dobbiamo trovare certe soluzioni pratiche. L'introduzione delle istruzioni che lavorano con le costanti.

La soluzione adottata è quella di caricare all'interno dell’istruzione, nei campi operando, la costante. Fare in modo che qualcuno dei formati d'istruzione abbia la possibilità di inserire una costante.

Quale formato è più idoneo?

Il formato I prevede infatti di avere:

• Codice operativo
• Due registri
• Una costante per lo spostamento

CARICAMENTO IN UN INDIRIZZO IN UN REGISTRO

Noi possiamo caricare l'indirizzo in un registro utilizzando l'istruzione: appena vista load immediate (li), facendo ciò però dobbiamo specificare il valore dell'indirizzo. (valore esteso 4 byte).

Risulterebbe più comodo se ci fosse un'istruzione che ci permettesse di caricare l'indirizzo nel registro di riferimento (come avviene nel costrutto C base, quando vado a salvare l'indirizzo nelle etichette).

A tale scopo ci viene incontro l'assemblatore che ci mette a disposizione l'istruzione di:

load address (la) → la $t0, etichetta.

Questo è possibile perché l'assemblatore usa la tavola dei simboli per ricavare l'indirizzo corrispondente all'etichetta.

LEZIONE 9: 29/03/21

INDIRIZZI NELLE ISTRUZIONI DI BRANCHES e JUMP

1. bne $t4, $t5, label
2. beq $t4, $t5, label
3. j label

FORMATO I (16 bit per indirizzo)

FORMATO J (26 + 2 bit per indirizzo)

FORMATO J:

• 26 bit disponibili per l'indirizzo < 32 bit (indirizzo)
• 2 bit perché gli indirizzi sono multipli di 4 byte (1 word), allora i 2 bit meno significativi sono sempre due zeri
• 4 bit mancanti = dedotto dal program counter corrente cioè io sovrascrivo i 28 bit del PC lasciando inalterati i 4 bit più significativi

32 bit

NON HANNO UNA VERA E PROPRIA IMPLEMENTAZIONE HARDWARE MA LA LORO PRESENZA NEL LINGUAGGIO È RESA POSSIBILE DALL'ASSEMBLATORE.

*Esempio:

(1) move $t0, $t1 → { odd $t0, $zero, $t1 }blt $t3, $t5, Lable → { slt $at, $s1, $s2bne $at, $zero, Lable }

*Esempio: (Azzeramento Valori Vettore)

AzzeramentoValori (int Vet[], int dim) {   int i;   for (i=0; i<dim; i++)      Vet[i]=0;}

*1° Soluzione:

Azzeramento:L1: add $t1, $t0, $t0odd $t1, $t1, $t1odd $t2, $t0, $t1sw $zero, 0($t2)odd $t0, $t0, 1slt $t3, $t0, $t1bne $t3, $zero, L1jr $ra

*Nota:In questa soluzione c'è un problema, non viene verificato subito il valore in dim, ma solo dopo aver eseguito un'iterazione

Nota:

Se invece del complemento alla base utilizzo il complemento alla base -1 allora occorre sommare il riporto al risultato finale.

*Esempio:

• (1) Complemento a 2:
• + 23 + (-17) -
• 001011 +
• 101111 =
• 1 000010 ← +2
• NON VA CONSIDERATO
• (2) Complemento a 1:
• + 23 + (-7)
• 001011 +
• 110010 =
• 1 000001 → +
• 000010 ← +2

*Sommatore (esempi)

• I → (+) → O
• (XOR)
• S | I | O
• 0 0 0
• 0 1 1
• 1 0 1
• 1 1 0
• a b → Σ c
• R₀ Σ Rᵢ
• ↓
• C

Se S = 0 allora O = I

Se S = 1 allora O = I

• q b Rᵢ C R₀
• 0 0 0 0 0
• 0 0 1 0 1
• 0 1 0 0 1
• 0 1 1 1 0
• 1 0 0 0 1
• 1 0 1 1 0
• 1 1 0 1 0
• 1 1 1 1 1

# Rilevazione Riporto

nor $t3, $t3, $zero

sltu $t3, $t3, $t2

bne $t3, $zero, carry

add $t0, $t3, $t2

j poi

carry:

poi:

*NOTA:

(2³² - 1) - t3 < t2?

(2³² - 1) < t3 + t2

*NOTE: (Indirizzo formato J)

Resto del Codice

addi $t4, $t3, 1

CIC: j cic

(indirizzo 0X00400020) Questo è il mio loop infinito

*codice per istruzione di salto (J)

0X08100008

binario

0000 10 00 0000 0000 0000 0000 0000

op INDIRIZZO (26 bit)

Prima di poter dare l'indirizzo devo mettere in posto due bit a 0 e aggiungerselo in coda i 4 bit del program counter corrente.

pc... 0X00... allora aggiungo 4 zeri

0000 (PC) 0000 (indirizzo) 00 (aggiuntivi)

*indirizzo ottenuto

0X001000020

Questo è l'indirizzo a cui salto e ciò mi permette di rimanere nel loop