Codice assembly

Codice macchina e codice assembly

In un calcolatore, le istruzioni macchina sono in codice binario. Esse vengono decodificate direttamente dalla cpu (hardware) che poi esegue le istruzioni operando sui dati (registri e memoria). 

Possiamo in teoria usare direttamente il linguaggio macchina (che nella quasi totalità delle implementazioni è come sappiamo in codice binario), ma per rendere questo codice comprensibile agli esseri umani, senza perdere in validità, gli sviluppatori preferiscono usare il linguaggio assembly, che da una corrispondenza delle istruzioni codice macchina con codici alfanumerici che rappresentano istruzioni, registri e valori). 

In questa lezione introduciamo una versione puramente didattica del linguaggio assembly, con un set limitato di istruzioni.

Nel presentare le istruzioni si ricorda che:
– la CPU presenta i registri di servizio PC, IR e SP (Program Counter, Instruction Register e Stack Pointer)

– la CPU presenta i registri dati R0… R9

– la memoria centrale è esterna alla cpu e ci si accede per caricare/scaricare celle da/verso i registri.

In linguaggio assembly ogni istruzione ha la forma:

#INDIRIZZO: CODICEISTRUZIONE operando1, operando2, operando3 

dove gli operandi possono essere da 0 a 3 (a seconda dell’istruzione).

Gli operandi possono essere:

– registri: nominati con prefisso $: ad esempio $R5, prende il valore contenuto nel registro

– valori assoluti: si indica il numero senza prefissi (es. “5”)

– indirizzi di memoria: si indica il numero con prefisso # (es. “#250” dove 250 è l’indirizzo di una cella di memoria)

Vediamo quindi le istruzioni:

Un esempio pratico

Esempio: vogliamo memorizzare la somma degli interi da 1 a n (cioè 1+2+3+…+n). 

Qui il codice C++:

int sum(int n) {  
  int result = 0;  
  for (int i=0; i<n; i++) {    
   result += i;  
  }  
  return result;
}

Useremo i seguenti registri per memorizzare il valore delle variabili:

$r0 -> n

$r1 -> result

$r2 -> i

$r3 -> registro di servizio che useremo per gestire il ciclo

$r8 -> contiene l’indirizzo di memoria fisica dove si trova n (inserito dall’utente)

$r9 -> contiene l’indirizzo di memoria fisica dove memorizzare il risultato result alla fine

Vediamo il codice (che ipotizziamo partire dall’indirizzo #10)

#10: LOD $r0, $r8 carichiamo in $r0 il valore della cella di memoria il cui indirizzo è in $r8
#11: LOD $r1, 0 carichiamo in $r1 il valore 0 (valore iniziale di result)
#12: LOD $r2, 0 carichiamo in $r2 il valore 0 (valore iniziale di i)
#13: ADD $r2, $r2, 1 incrementiamo $r2 di 1
#14: ADD $r1, $r1, $r2 sommiamo a $r1 il valore di $r2
#15: SUB $r3, $r0, $r2 memorizziamo in $r1 il risultato della sottrazione $r0 - $r2 (n-i)
#16: BNE $r3, 0, #13 se il risultato non è 0 (cioè se n-i != 0) allora saltiamo all'istruzione #13 (3 è l'etichetta) e il ciclo ricomincia
#17: STO $r1, $r9 memorizza nell'indirizzo di memoria indicato da $r9 il valore di $r1, cioè il risultato

TPSI – Elenco istruzioni assembly

Elenco istruzioni con tutti gli operatori

Note:

– $ indica il prefisso di un registro, # indica un prefisso di un indirizzo, senza prefissi è un valore assoluto;

– i registri della CPU sono PC (program counter), IR (istruzione corrente) e SP (indirizzo prima cella libera dello stack), ed infine R0…R9 (registri dati);

– si ricorda che in condizioni normali al termine di una istruzione, il PC viene incrementato di 1;

– l’esecuzione di una istruzione di salto consiste nel sovrascrivere il PC con l’indirizzo verso cui bisogna saltare;

– occorre fare attenzione al contenuto dei registri:

– nelle istruzioni aritmetico-logiche, il contenuto del registro è considerato un valore;

– nelle istruzioni di salto, quando viene usato un registro per indicare l’istruzione verso cui saltare, il valore sarà considerato un indirizzo (quindi “5” sarà considerato “#5”).

– nelle istruzioni di memoria, la sorgente è sempre un valore, la destinazione è sempre un indirizzo.

– la PUSH verso lo stack è sempre data dalla coppia di istruzioni:

in quanto è necessario aggiornare SP alla prima posizione libera.

– la PULL dallo stack è sempre data dalla coppia di istruzioni:

dove RX è un generico registro. E’ necessario in questo caso aggiornare SP all’ultima posizione occupata.

In conclusione

– per un semplice ciclo sono necessarie più operazioni a basso livello rispetto a quelle ad alto livello. 

– il codice macchina (di cui vediamo) è composto da istruzioni semplici e poco costose da realizzare 

– le istruzioni hanno lo stesso tempo di esecuzione

Un set di istruzioni reale è molto più ampio, e si diversifica per architettura, secondo tecnologie che si sono evolute soprattutto con l’avvento dei microprocessori e le architetture moderne, come RISC e CISC (che differivano proprio per la complessità delle istruzioni) con le loro più recenti evoluzioni (X86  -tecnologia del mercato desktop – e ARM – tecnologia del mercato mobile).