Sistemi E Reti

Primo Programma

Stampa WhatsApp Email

Introduzione al linguaggio Assembly (template .COM), focalizzata sulla struttura base, l'uso di commenti, la direttiva ORG 100h e le istruzioni fondamentali MOV, ADD e RET, utilizzando l'emulatore emu8086.

Durata

PT20M

Software

emu8086

1 Introduzione all'Assembly .COM (circa 10 minuti)

L'Assembly è un linguaggio di programmazione di basso livello, che utilizza mnemonici (codici brevi) per rappresentare le istruzioni che il microprocessore può eseguire direttamente. Programmare in Assembly ci permette di capire a fondo come funziona l'hardware.

Il formato .COM è uno dei formati più semplici e antichi per i programmi eseguibili su architettura x86, tipicamente DOS. Questi programmi sono caricati nella memoria RAM in un unico segmento e l'esecuzione inizia da un preciso offset.

2 La Direttiva ORG 100h

L'istruzione ORG 100h (o ORG 256 in decimale) è cruciale per i programmi .COM.

  • Significato: ORG (Origin) dice all'assemblatore di impostare l'indirizzo di partenza del codice (l'offset) a 100h (256 in esadecimale).
  • Motivazione: I primi 256 byte (0000h a 00FFh) del segmento di memoria sono riservati dal sistema operativo (in ambiente DOS) per memorizzare il Program Segment Prefix (PSP), una struttura dati fondamentale per la gestione del programma. Il nostro codice effettivo deve iniziare subito dopo.

3 Commenti per la Leggibilità

Come in qualsiasi linguaggio di programmazione, i commenti sono fondamentali. In Assembly x86, i commenti iniziano con il punto e virgola (;). 


ORG 100h        ; Inizio del codice dopo il PSP
MOV AX, 5       ; Sposta il valore 5 nel registro AX

4 Istruzioni Fondamentali: MOV e ADD

Queste sono due delle istruzioni più basilari e utilizzate, che operano principalmente sui Registri del microprocessore, ovvero delle piccole aree di memoria interne alla CPU estremamente veloci (AX, BX, CX, DX sono i registri generici a 16 bit).

Istruzione Descrizione Sintassi di Base Esempio
MOV (Move) Copia il valore dall'operando sorgente (il secondo) all'operando destinazione (il primo). Attenzione: non è un "sposta", ma una "copia". MOV destinazione, sorgente MOV BX, AX (Copia il contenuto di AX in BX)
ADD (Add) Somma il valore dell'operando sorgente all'operando destinazione. Il risultato viene memorizzato nella destinazione. ADD destinazione, sorgente ADD CX, 10 (Somma 10 al valore di CX)

5 L'Istruzione RET (Return)

Dopo aver eseguito il codice, è necessario indicare al microprocessore che il programma è terminato e che deve restituire il controllo al sistema operativo.

  • Funzione: RET (Return) termina l'esecuzione del programma .COM e restituisce il controllo al sistema operativo (DOS).
  • Posizione: Deve essere l'ultima istruzione del programma.

6 Struttura del Primo Programma Assembly .COM

Mettendo insieme quanto appreso, la struttura minimale del nostro primo programma Assembly .COM sarà: 


ORG 100h        ; Imposta l'offset di inizio codice a 100h

; Corpo principale del programma (istruzioni)
MOV AX, 1234h   ; Carica un valore nei registri
ADD AX, 1       ; Esegue una semplice operazione aritmetica

RET             ; Termina il programma e ritorna al sistema operativo
LABORATORIO

Semplici somme in Assembly

Mettiamo in pratica le istruzioni MOV, ADD e RET per creare un programma che esegue una semplice somma tra due numeri.

1 Creazione e Struttura del Programma in emu8086 (circa 5 minuti)

Segui i passaggi per creare il file e impostare la struttura di base:

  • Apri emu8086 e seleziona "New".
  • Scegli "Empty Workspace".
  • Digita la struttura base di un programma .COM:

ORG 100h

; Qui andranno le istruzioni

RET

Obiettivo: Caricare due numeri nei registri e sommarli. Useremo il registro AX per il primo numero e il registro BX per il secondo numero. Il risultato sarà salvato nel registro AX.

2 Implementazione delle Istruzioni

Inserisci le istruzioni MOV e ADD nel corpo del programma per eseguire la somma 15 + 20.

  1. Utilizza MOV per caricare i valori iniziali nei registri AX e BX:
    2. 
    ORG 100h

    MOV AX, 15      ; Carica il primo valore (15) nel registro AX
    MOV BX, 20      ; Carica il secondo valore (20) nel registro BX

    RET
  2. Utilizza ADD per sommare il contenuto di BX al contenuto di AX (risultato in AX):
    3. 
    ORG 100h

    MOV AX, 15      ; AX = 15
    MOV BX, 20      ; BX = 20
    
    ADD AX, BX      ; Somma BX ad AX. Ora AX = 15 + 20 = 35

    RET             ; Termina il programma

3 Compilazione ed Esecuzione

Per verificare il funzionamento e osservare l'effetto sui registri:

  • Fai clic sul pulsante "Compile" (Compila) in emu8086.
  • Fai clic sul pulsante "Run" (Esegui) per aprire l'emulatore.
  • Nell'interfaccia dell'emulatore, osserva la sezione dei Registri (Registers).
  • Usa il pulsante "Single Step" (Passo Singolo) per eseguire una istruzione alla volta.
  • Osservazione: Dopo l'istruzione MOV AX, 15, il registro AX dovrà contenere 000Fh (15 decimale in esadecimale). Dopo l'istruzione ADD AX, BX, il registro AX dovrà contenere 0023h (35 decimale in esadecimale).

4 Altri esercizi

Modifica il programma appena creato per:

  • Scambiare i valori di due registri
  • Sommare 3 valori: 4, 5 e 6
  • Sommare 300, 5 e 6
  • Prelevare il valore di AX e scrivere in bx il precedente e in cx il successivo
  • Sottrarre da 100: 20 e 25
  • Sottrarre 50 da 100 e sommare 20



Assembly, emu8086, .COM, MOV, ADD, RET, ORG 100h, Struttura Programma,