Dal linguaggio macchina al C

I primi computer si programmavano direttamente in linguaggio macchina, cambiando i bit dei registri con interruttori o schede perforate. È un po' come l'esecuzione passo per passo che si usa ancora oggi per controllare l'hardware mentre lo si progetta.

In pratica ogni riga di assembly corrisponde a una istruzione macchina: l'assembler sostituisce ogni nome con il suo codice numerico (slide 4).

Il problema: sommare due numeri interi che stanno in memoria agli indirizzi $A=400$ e $B=404$, e mettere il risultato nella cella all'indirizzo $A$. Il linguaggio è un assembly di tipo RISC, come quello del processore MIPS32. Il programma fa quattro cose:

1. definisce gli indirizzi A e B;
2. carica i due numeri nei registri R0 e R1 della CPU, con due istruzioni LOAD;
3. li somma con un'istruzione ADD tra i registri R0 e R1;
4. copia il risultato dal registro R0 all'indirizzo A della memoria, con un'istruzione STORE.

ADDR  A = 400        ; definisce l'indirizzo A
ADDR  B = 404        ; definisce l'indirizzo B
LOAD,  R0, @A        ; carica in R0 il numero all'indirizzo A
LOAD,  R1, @B        ; carica in R1 il numero all'indirizzo B
ADD,   R0, R1        ; R0 ← R0 + R1
STORE, R0, @A        ; copia R0 all'indirizzo A

Il simbolo @A vuol dire «il contenuto della memoria all'indirizzo A», non il numero 400. Le righe ADDR non diventano istruzioni: servono solo a dare un nome agli indirizzi.

Che cosa succede nella macchina (slide 7–14)

In memoria il programma occupa i byte 0–15 (4 istruzioni da 4 byte), i dati stanno a 400 (il numero 12) e a 404 (il numero $-8$). Le slide seguono l'esecuzione con due passi per istruzione: prima il prelievo («carica la prossima istruzione leggendo il program counter nell'instruction register»), poi l'esecuzione («decodifica IR ed esegue l'istruzione elementare»).

Il PC avanza di 4 in 4 (0, 4, 8, 12), perché ogni istruzione occupa una parola da 32 bit. Alla fine all'indirizzo 400 non c'è più 12 ma $4=12+(-8)$: il risultato è nello stato finale della memoria, come diceva la lezione 01B.

Ora la stessa moltiplicazione per somme ripetute della lezione 01A. I numeri stanno agli indirizzi simbolici m e n; il risultato va all'indirizzo m. Si usano l'accumulatore $s$ (nel registro R0) e il contatore $i$ (in R1).

 1.  LOAD,  R0, 0         // inizializza R0 come accumulatore s
 2.  LOAD,  R1, 0         // inizializza R1 come contatore i
 3.  LOAD,  R2, @m        // carica il valore all'indirizzo m in R2
 4.  LOAD,  R3, @n        // carica il valore all'indirizzo n in R3
 5.  CMP    R1, R3        // confronta R1 ed R3, cioè i ed n
 6.  JMPEQ  <riga 10>     // se i = n salta alla riga 10, altrimenti continua
 7.  ADD,   R0, R2        // R0 ← R0 + R2, cioè s ← s + m
 8.  INC,   R1            // R1 ← R1 + 1, cioè i ← i + 1
 9.  JMP    <riga 5>      // salto incondizionato alla riga 5
10.  STORE, R0, @m        // salva R0, cioè il risultato s, all'indirizzo di m

Le istruzioni nuove:

È esattamente la versione V6 della lezione 01A, riga per riga:

Prova il simulatore con $m=4$, $n=3$ e poi con $n=0$: conta quante volte viene eseguita la riga 5.

Perché l'assembly non basta (slide 17)

• È faticoso e facile sbagliare: 4 righe per un'addizione, 10 per una moltiplicazione.
• Richiede di conoscere l'architettura della CPU (registri, istruzioni).
• Non si vede la struttura del codice né la logica: dove comincia e dove finisce la ripetizione?
• Il codice scritto per la CPU X va riscritto da capo per la CPU Y, se i linguaggi macchina sono diversi.

Per questo, dagli anni '50, si sviluppano linguaggi di programmazione con istruzioni di livello semantico più vicino al linguaggio matematico e naturale, che permettono di astrarre il programma dalle caratteristiche dell'hardware.

Il FORTRAN (slide 18–20)

All'inizio degli anni '50 IBM progetta il calcolatore modello 704 per i calcoli scientifici, con due requisiti:

• gli scienziati devono potersi concentrare sulla programmazione di formule, ignorando i dettagli della CPU;
• i programmi devono potersi trasportare sui futuri modelli IBM senza riscriverli da capo.

Per il 704 nasce il FORTRAN (FORmula TRANslator):

• un compilatore traduce ogni istruzione FORTRAN in una o più istruzioni assembly della macchina usata;
• se cambia la macchina, basta ricompilare il programma;
• insieme a LISP, ALGOL e COBOL è tra i capostipiti dei linguaggi di terza generazione, la famiglia del C originario che studierai in questo corso;
• le versioni moderne (FORTRAN 90) hanno costrutti come if e while.

La moltiplicazione in FORTRAN (slide 20):

Program Hello
INTEGER :: m
INTEGER :: n
INTEGER :: s
INTEGER :: i

WRITE(*,*) 'Inserisci m:'
READ(*,*) m
WRITE(*,*) 'Inserisci n:'
READ(*,*) n

s = 0
i = 0
do while (i<n)
    s = s + m
    i = i + 1
end do

WRITE(*,*) "Risultato :",s
End Program Hello

Le 10 righe di assembly diventano 6 righe leggibili (da s = 0 a end do): la ripetizione è un blocco do while … end do e i salti non si vedono più, li scrive il compilatore. In più il programma chiede $m$ e $n$ a chi lo usa (READ) e stampa il risultato (WRITE).

L'albero dei linguaggi (slide 21–22)

La slide 21 mostra come i linguaggi discendono uno dall'altro, dal 1956 al 2004: dal Fortran I e da ALGOL 60 nasce, tra gli altri, il C (versione K&R, fine anni '70), da cui discendono C++, e poi Java, C#, e in parte Python. Imparare il C vuol dire imparare la base di molti linguaggi usati oggi.

Punti chiave della prima parte (slide 22):

• abbiamo scritto un semplice algoritmo per moltiplicare interi come somma ripetuta;
• si può programmare la macchina a basso livello (assembly), ma scrivere programmi è lungo e difficile;
• i linguaggi di alto livello come il C nascondono molti dettagli dell'hardware sottostante.

while (i < n) {
    s = s + m;
    i = i + 1;
}

        jmp  .L2                      ; salta subito al controllo
.L3:    mov  eax, DWORD PTR -12[rbp]  ; carica m (LOAD)
        add  DWORD PTR -4[rbp], eax   ; s ← s + m (ADD)
        add  DWORD PTR -8[rbp], 1     ; i ← i + 1 (INC)
.L2:    mov  eax, DWORD PTR -8[rbp]   ; carica i
        cmp  eax, DWORD PTR -16[rbp]  ; confronta i con n (CMP)
        jl   .L3                      ; se i < n torna al corpo (salto condizionato)

• 1969: Ken Thompson (Bell Labs, AT&T) sviluppa il sistema operativo Unix per il minicomputer PDP-7, scritto inizialmente in assembly.
• L'esperienza mostra che l'assembly rende lo sviluppo di un sistema operativo oneroso e poco flessibile.
• Dennis Ritchie progetta allora il linguaggio C, pensato per unire efficienza e portabilità.
• Unix viene riscritto progressivamente in C: si diffonde (a partire dalle università) e influenza in modo decisivo la storia dell'informatica.
• 1972: prima versione del C, per uso interno sui PDP-7 e PDP-11, oggi nota come K&R C (dalle iniziali di Kernighan e Ritchie, autori del libro che lo descrisse).
• Alla fine degli anni '80 il C viene standardizzato da ANSI e ISO (ANSI C, C89), per usarlo su hardware molto diversi.
• Lo standard è stato aggiornato più volte: C99, C11, C17, C23. Il libro di testo del corso fa riferimento al C11.

Nonostante l'età, il C è ancora centrale: è il linguaggio di riferimento per sistemi operativi, compilatori, driver, librerie di basso livello, applicazioni ad alte prestazioni e sistemi embedded/IoT. Offre un controllo diretto su hardware e memoria, restando molto più astratto dell'assembly.

// Un primo programma in C
#include <stdio.h>

// La funzione "main" e' il punto di ingresso del programma
int main(void) {
    printf("Buongiorno dal C.\n");
}
// fine della funzione main

Compilato con gcc -Wall -Werror stampa Buongiorno dal C. e va a capo. Vediamolo pezzo per pezzo.

Commenti (slide 28)

Le righe che iniziano con // sono commenti: non sono istruzioni e il compilatore le ignora. Servono a chi legge: un commento prima di una funzione o di un gruppo di istruzioni ne chiarisce lo scopo (slide 32). Il codice deve essere comprensibile per un programmatore, non solo per il compilatore.

La direttiva #include (slide 29)

• Le righe che iniziano con # sono direttive per il preprocessore (argomento che si vedrà poco qui e meglio in Programmazione II).
• #include <stdio.h> include nel programma il file stdio.h (standard input/output header) e ne importa le definizioni.
• I file .h si chiamano file di intestazione (header): contengono le dichiarazioni di funzioni, per esempio quelle delle librerie di sistema (printf() sta nella libreria C, libc).
• stdio.h dichiara funzioni come printf() e scanf().
• Nelle slide a volte gli #include sono omessi, solo per ragioni di spazio.

La funzione main (slide 30–31)

• I programmi C sono organizzati in moduli chiamati funzioni, che contengono le istruzioni da eseguire. Ogni funzione ha un input e un output.
• La funzione main è obbligatoria: è il punto da cui comincia l'esecuzione.
• (void) vuol dire che main riceve un input vuoto.
• int vuol dire che main restituisce un intero: un codice di successo o di errore per il sistema operativo (nel corso non lo useremo). Il compilatore permette di ometterlo, ma si può scrivere esplicitamente return 0; prima della graffa finale.
• Per ora tutto il codice va dentro il main.

Blocchi e programmazione strutturata (slide 32–33)

• Le parentesi graffe { } delimitano il corpo (body) della funzione, cioè un blocco di istruzioni. Devono essere sempre bilanciate: ogni { ha la sua }.
• Un blocco è un'unità logica e può contenere: dichiarazioni di dati (le variabili), comandi, chiamate di altre funzioni e altri blocchi (annidati, sempre tra graffe).
• Per convenzione il codice C si indenta con le tabulazioni (il tasto Tab).

Sono i blocchi Inizio/Fine della versione V6 della lezione 01A, scritti con le graffe.

Programmare per la chiarezza (slide 34)

«Il codice è letto molto più spesso di quanto venga scritto: programmate per la chiarezza, non per la brevità.» (citazione attribuita a Donald Knuth nella slide 34)

Per mantenere il codice chiaro:

• indentazione corretta, che mostri la struttura logica;
• commenti significativi, soprattutto per funzioni e parti complesse;
• nomi descrittivi per variabili e funzioni, così che il codice si spieghi da solo;
• blocchi non troppo lunghi: meglio spezzare in funzioni più piccole e riutilizzabili (lo vedrai più avanti).

printf, istruzioni e stringhe (slide 35–36)

• printf(…) è una chiamata di funzione (function call): si chiama la funzione passandole i parametri di input tra parentesi.
• Ogni istruzione (statement) termina con il punto e virgola ;.
• Una stringa è un pezzo di testo tra doppi apici "…".
• Dentro le stringhe possono comparire sequenze di escape (sequenze speciali), che cominciano con la barra rovesciata \ (backslash).

Per ora printf si usa solo con testo tra doppi apici. Per esempio:

printf("Ha detto \"ciao\"\n");     // stampa: Ha detto "ciao"
printf("C:\\corso\\lab1\n");        // stampa: C:\corso\lab1
printf("nome\tvoto\n");             // stampa nome e voto separati da una tabulazione

Sintassi e token (slide 37–38)

Il C va compilato: il codice sorgente, che è testo, viene tradotto in linguaggio macchina. Durante la compilazione l'analizzatore lessicale (parser) divide il codice in token, le unità sintattiche: parole chiave, identificatori, operatori, punteggiatura, stringhe, costanti. Come una lingua naturale, un linguaggio di programmazione ha una sintassi, più formale, con le regole per scrivere programmi corretti. Se una regola non è rispettata, il compilatore segnala un errore di compilazione e non produce il programma.

Tre regole da sapere subito:

1. Ogni istruzione termina con ;. Errore tipico: dimenticarlo. gcc risponde expected ';' before ….
2. Un'istruzione può occupare più righe: si può andare a capo ovunque sia ammesso uno spazio. Due stringhe una dopo l'altra vengono unite:

   printf("Questo è un messaggio "
          "spezzato su più righe\n");

3. Non si va a capo dentro una stringa senza chiuderla: errore missing terminating " character.

Identificatori (slide 39–40)

Gli identificatori sono i nomi che dai agli elementi del programma (variabili, funzioni, costanti, tipi…), per poterli riconoscere e usare.

• Maiuscole e minuscole contano (case-sensitive): Var, var e VAR sono tre identificatori diversi.

• Scegli nomi chiari: evita nomi troppo simili tra loro o senza significato. Esempi: somma, accumulatore.

• Non si possono usare le parole chiave del linguaggio:

  auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while

• Non usare i nomi delle funzioni della libreria standard, come main e printf (anche se non le usi, come sin e cos), né i nomi definiti nei file di intestazione.

Indentazione (slide 41)

Le istruzioni di un blocco (non le graffe) si scrivono rientrate di un numero fisso di spazi (per esempio 4) o, meglio, con il carattere Tab. L'indentazione aiuta a capire il flusso del programma, e va fatta mentre si programma, non dopo.

if (a > 15) {
    x = 5;
    y = 2;
    z = a + b;
}

L'if arriverà nelle prossime settimane: qui conta la forma, con le tre istruzioni rientrate dentro le graffe.

Il percorso (slide 42): i file sorgente (.c, il codice in forma di testo; ognuno è un'unità di compilazione) includono i file di intestazione (.h). Preprocessore, compilatore e assemblatore trasformano ogni sorgente in un file oggetto (linguaggio macchina); il collegatore (linker) unisce i file oggetto in un programma eseguibile.

Il compilatore del corso è gcc (la slide dice GNU C Compiler; oggi il nome è GNU Compiler Collection): libero, conforme agli standard, disponibile per i principali sistemi operativi, capace di produrre codice per molte architetture. È un frontend per un sistema di compilazione a più stadi (slide 43–44):

Compilare ed eseguire (slide 45)

Per ora si compila così:

Unix:     gcc -Wall -Werror sorgente.c -o eseguibile
Windows:  gcc -Wall -Werror sorgente.c -o eseguibile.exe

• -Wall attiva gli avvisi (warning) più utili;
• -Werror trasforma ogni avviso in errore: con un solo avviso il programma non viene prodotto;
• -o eseguibile sceglie il nome del file prodotto.

Poi si esegue: ./buongiorno nella shell di Unix, buongiorno nel Prompt dei comandi di Windows.

Un programma può compilare senza errori di sintassi e contenere lo stesso errori che si vedono solo durante l'esecuzione (runtime). Le cause possono essere:

• una progettazione sbagliata dell'algoritmo, per esempio eseguire un ciclo prima di verificarne la condizione di terminazione (è il bug della versione V2 della lezione 01A);
• una realizzazione sbagliata del programma, per esempio una divisione per zero o un accesso non valido alla memoria.

Un errore di compilazione (slide 47)

#include <stdio.h>

int main(void) {
    printf("Buongiorno dal C.\n")
}

Manca il ; alla riga 4. gcc 16.1 risponde così (verificato):

manca.c:4:34: error: expected ';' before '}' token

I numeri 4:34 sono riga e colonna: il compilatore dice dove si è accorto del problema. A volte è la riga dopo l'errore vero, perché se ne accorge solo quando trova il simbolo successivo (qui la } della riga 5): guarda sempre anche la riga prima.

Un errore a runtime (slide 48)

#include <stdio.h>
int main(void) {
    int x = 5;
    int y = 0;
    printf("5/2 uguale a %d\n", x/y);
}

Il programma compila senza errori anche con -Wall -Werror, ma all'esecuzione divide per zero. Nella slide, su Linux, il programma si interrompe con il messaggio Eccezione in virgola mobile (anche se la divisione è tra interi: il nome del segnale è storico). Su Windows il programma si interrompe in modo anomalo senza stampare il risultato. Il %d dentro la stringa serve a stampare un numero intero: lo vedrai presto.

1. Scrivi o modifica il sorgente con un editor di testo (per esempio Notepad++).
2. Salva il file con estensione .c in una cartella.
3. Compila con gcc.
4. Analizza e correggi gli errori di sintassi: leggi con attenzione che cosa dice il compilatore.
5. Esegui il programma.
6. Verifica che si comporti in modo corretto (test).
7. Se qualcosa non va, correggi e ricomincia.

Prerequisiti: saper scrivere e gestire file di testo, muoversi tra le cartelle, usare la linea di comando (shell) per le cose essenziali. Sul tuo PC dovrai installare un ambiente con il compilatore gcc (se ne occupano i laboratori). Per iniziare senza installare niente c'è l'ambiente online pythontutor.com/c.html, che mostra anche lo stato della memoria passo per passo.

L'esame di Programmazione I è al PC su Moodle, con esercizi in C corretti anche da test automatici (CodeRunner), comune ai canali A, B e C. Questa lezione ti dà gli strumenti di base:

• compilare sempre con -Wall -Werror, come all'esame: anche un solo avviso blocca la compilazione;
• leggere i messaggi del compilatore: riga, colonna e descrizione (expected ';', missing terminating " character, implicit declaration of function);
• all'esame si scrive in un editor di testo semplice, senza IDE né completamento automatico: esercitati così, anche con Notepad++;
• provare i programmi su più casi, compresi quelli limite: i test automatici lo faranno;
• il modello «istruzione dopo istruzione» dell'assembly è la base degli esercizi sullo stato della memoria.

Linguaggio macchina

Istruzioni in forma numerica (bit), eseguite direttamente dal processore; diverso per ogni architettura.

Instruction set

L'insieme delle istruzioni macchina di un'architettura.

Assembly

Rappresentazione simbolica del linguaggio macchina, con mnemonici come LOAD, ADD, STORE.

Assembler

Programma che traduce l'assembly in linguaggio macchina.

LOAD / STORE

Copiano un dato dalla memoria a un registro / da un registro alla memoria.

CMP

Confronta due registri; l'esito resta nella CPU (registro di stato).

Salto condizionato / incondizionato

JMPEQ salta solo se l'ultimo confronto ha dato «uguali»; JMP salta sempre.

Linguaggio di alto livello

Linguaggio con istruzioni vicine al linguaggio matematico e naturale, indipendente dall'hardware.

Compilatore

Programma che traduce un linguaggio di alto livello in linguaggio macchina (o in assembly).

Portabilità

Possibilità di usare lo stesso programma su macchine diverse, ricompilandolo.

FORTRAN

FORmula TRANslator, linguaggio IBM degli anni '50 per il calcolo scientifico.

Commento

Testo ignorato dal compilatore: da // a fine riga, oppure tra /* e */.

Direttiva del preprocessore

Riga che inizia con #, come #include.

File di intestazione (header)

File .h con dichiarazioni di funzioni, come stdio.h.

Funzione main

La funzione obbligatoria da cui comincia l'esecuzione.

Blocco

Gruppo di istruzioni tra graffe { }; i blocchi si possono annidare.

Istruzione (statement)

Un comando del programma; in C termina con ;.

Stringa

Testo tra doppi apici.

Sequenza di escape

Coppia di caratteri che inizia con la barra rovesciata e rappresenta un carattere speciale: \n, \t, \\, \", \0.

Token

Unità sintattica in cui il parser divide il codice: parole chiave, identificatori, operatori, stringhe, costanti.

Identificatore

Nome di una variabile, funzione, costante o tipo; distingue maiuscole e minuscole.

Parola chiave (keyword)

Parola riservata del C, come int, while, return.

File oggetto

Unità di compilazione tradotta in linguaggio macchina (.o).

Linker

Unisce file oggetto e librerie in un programma eseguibile.

gcc

Il compilatore del corso (GNU Compiler Collection).

Errore a runtime

Errore che si manifesta durante l'esecuzione.

Errore logico

Il programma gira ma non fa ciò che dovrebbe.

Spunta quando sai fare la cosa senza guardare gli appunti. Le spunte restano salvate in questo browser.

• So spiegare la differenza tra linguaggio macchina e assembly e perché nessuno dei due è portabile.
• So eseguire a mano il programma dell'addizione, con PC, registri e memoria dopo ogni istruzione.
• So leggere il programma della moltiplicazione in assembly e collegarlo riga per riga alla versione V6 della lezione 01A.
• So spiegare CMP, JMPEQ e JMP e come formano un ciclo.
• So dire perché sono nati i linguaggi di alto livello e che cosa fa un compilatore.
• So raccontare in breve la nascita del C e le sue quattro caratteristiche.
• So spiegare ogni riga del programma «Buongiorno dal C.».
• So usare le sequenze di escape \n, \t, \\, \" in printf.
• So riconoscere un identificatore valido e le parole chiave.
• So elencare gli stadi della compilazione e compilare con gcc -Wall -Werror.
• So distinguere errori di compilazione, a runtime e logici, e leggere un messaggio di gcc.