LA STRUTTURA DI UN PROGRAMMA ASSEMBLY

LA STRUTTURA DI UN PROGRAMMA ASSEMBLY
Un programma, secondo la sintassi assembly, deve dichiarare i come deve essere utilizzata la memoria e come viene suddivisa nei quattro segmenti fondamentali

  • dati
  • stack
  • codice
  • extra

I segmenti possono essere dichiarati secondo due diverse direttive, chiamate:

  1. direttive standard
  2. direttive semplificate

1 Direttive strandard
;==========================================================
;strutt.ASM
;Struttura programma assembly
; Realizzato da: Classe: Data:
;==========================================================
Dati SEGMENT ;direttiva che dichiara il segmento Dati
Num1 DW 6533 ;variabile di nome NUM1 di 16 bit con valore 6533
Num2 DW ? ;variabile di nome NUM2 di 16 bit non inizializzata
Num3 Db 0;variabile di nome NUM3 di 8 bit con valore 0
MSG Db “Struttura di un programma assembly$”;variabile di nome MSG contenente una stringa di caratteri che deve sempre terminare con $
Dati ENDS ;fine segmento
Sistema SEGMENT STACK ;direttiva che dichiara
;il segmento STACK
DW 100 DUP (?)
Top LABEL WORD
Sistema ENDS ;fine segmento
Codice SEGMENT ;direttiva che dichiara
;l’inizio del segmento Codice
;ASSUME associa ad ogni registro di
;segmento il nome che identifica il segmento
ASSUME CS:Codice, DS:Dati, SS:Sistema, ES:Dati
Inizio:
;Inizializzazione dei registri di segmento
MOV AX,Sistema
MOV SS,AX
LEA AX,Top
MOV SP,AX
MOV AX,Dati
MOV DS,AX
MOV ES,AX
;programma
;da inserire il codice del programma 
;ritorno al sistema operativo
MOV AH,4Ch
INT 21h
Codice ENDS ;fine segmento
2 direttiva semplificata

L’assembler TASM ha introdotto direttive di segmentazione semplifi cate che consentono al programmatore di scrivere il codice risparmiando alcune righe di direttive. Si tratta di un formalismo  che consente una maggior concisione nella stesura dei programmi; le direttive semplifi cate si scrivono facendole iniziare con il punto (.). Il codice seguente mostra la sintassi e la struttura tipica

;==========================================================
;strutt.ASM
;Struttura programma assembly
; Realizzato da: Classe: Data:
;==========================================================

.MODEL SMALL ;direttiva all’assemblatore per usare
;un segmento Codice e un segmento Dati separati
.DATA ;direttiva che dichiara il segmento Dati
Num1 DW 6533 ;variabile di nome NUM1 di 16 bit con valore 6533
Num2 DW ? ;variabile di nome NUM2 di 16 bit non inizializzata
Num3 Db 0;variabile di nome NUM3 di 8 bit con valore 0
MSG Db “Struttura di un programma assembly$”;variabile di nome MSG contenente una stringa di caratteri che deve sempre terminare con $
.STACK ;direttiva che dichiara il segmento STACK di 1024 byte
.CODE ;direttiva che dichiara l’inizio del segmento Codice
Inizio:
;Inizializzazione dei registri di segmento
MOV AX,@DATA ;in AX viene posto l’indirizzo del segmento
MOV DS,AX ;Dati per poterlo assegnare al registro DS
;programma

;da inserire il codice del programma 
;ritorno al sistema operativo
MOV AH,4Ch
INT 21h
END Inizio
END

La chiusura del programma avviene mediante un servizio del sistema operativo DOS che chiude effettivamente l’esecuzione liberando la memoria in uso dal programma:
MOV AH,4Ch
INT 21h
Tale servizio deve essere usato anche nei sistemi operativi Windows.

La direttiva .MODEL identifi ca le dimensioni dei segmenti in uso. In questo caso abbiamo indicato SMALL ma ne esistono anche altri:

1 TINY Il codice del programma consente salti di tipo NEAR, cioè effettuabili solo all’interno del segmento di codice. Inoltre, poiché i segmenti dati e codice coincidono, viene usato per creare fi le eseguibili con estensione .com, cioè non rilocabili.

SMALL Il codice del programma consente salti di tipo NEAR, cioè effettuabili solo all’interno del segmento di codice. I segmenti dati e codice sono diversi, cioè in sostanza i registri CS e DS puntano a indirizzi diversi.

3 MEDIUM Il codice del programma consente salti di tipo FAR, cioè effettuabili anche al di fuori del segmento di codice. I segmenti dati e codice sono diversi, cioè in sostanza i registri CS e DS puntano a indirizzi diversi.

4  COMPACT  Il codice del programma consente salti di tipo NEAR, cioè effettuabili solo all’interno del segmento di codice, mentre il segmento dati consente salti di tipo FAR, cioè effettuabili anche al di fuori del segmento. I segmenti dati e codice sono diversi, cioè in sostanza i registri CS e DS puntano a indirizzi diversi.

LARGE Il codice del programma consente salti di tipo FAR,cioè effettuabili anche al di fuori del segmento di codice, il segmento dati consente salti di tipo FAR, cioè effettuabili anche al di fuori del segmento. I segmenti dati e codice sono diversi, cioè in sostanza i registri CS e DS puntano a indirizzi diversi. Gli array possono avere una dimensione inferiore a 64 k.

HUGE  Il codice del programma e il segmento dati consentono salti di tipo FAR, cioè effettuabili anche al di fuori del segmento di codice. I segmenti dati e codice sono diversi, cioè in sostanza i registri CS  e DS puntano a indirizzi diversi. Gli array possono avere una dimensione superiore a 64 k

Schermata 2015-02-21 alle 13.50.17

Ciclo di vita di un programma
La creazione, lo sviluppo, l’esecuzione e la messa a punto di un programma, segue un certo numero di fasi caratterizzate da attività specifiche, tempi specifici, applicazioni di supporto specifiche, errori specifici e file specifici. E’ possibile sintetizzare il ciclo di vita di un programma tramite un diagramma e una tabella che riportano fasi, tempi, applicazioni, files ed
errori relativi ad ogni fase.

Schermata 2015-02-21 alle 13.58.26

Fase di edit
Il programmatore scrive il testo del programma (moduli o files sorgenti) con la sintassi di un linguaggio di programmazione. Spesso i programmi  sono costituiti da più sorgenti, ma solo uno contiene l’entry point del  programma. I rimanenti testi sono denominati librerie di codice. Il programma utilizzato per scrivere il testo di un programma è un editor.

Fase di compilazione
Una volta completato un modulo sorgente, esso deve essere assemblato,  ovvero le istruzioni e le pseudoistruzioni presenti nei sorgenti in linguaggio simbolico, devono essere trasformate in assembly, a basso livello. Ogni file sorgente quindi viene ridotto, da un programma di supporto denominato assemblatore, a un file binario corrispondente (detto anche file oggetto).

TASM nome.asm

Schermata 2015-02-21 alle 15.38.31

Si possono verificare i tipici errori di sintassi (del linguaggio scelto) che sono sempre segnalati dai programmi compilatori, sotto forma di errori e/o warning.

Schermata 2015-02-21 alle 15.41.16

Dopo l’assemblaggio, è necessaria la correlazione (linking), ad opera di un secondo programma a supporto, denominato linker. Il linker collega tutti i files oggetto in uno solo, e genera il file eseguibile (target della compilazione), aggiungendovi, nella sua parte iniziale, la  porzione di startup e l’eventuale header.

TLINK nome.obj

Schermata 2015-02-21 alle 15.39.14

Fase di caricamento
Una volta su disco, il programma eseguibile deve essere caricato in memoria dal Sistema Operativo per essere poi trasformato in processo. Il Sistema Operativo legge lo header del file eseguibile e carica in memoria il programma, dopo di chè cede il controllo al codice di startup dell’eseguibile. Spesso i Sistemi Operativi creano una zona di memoria di
collegamento con il programma  prima di cedere il controllo.

nome.exe
Fase di esecuzione
Il runtime è il tempo durante il quale il processo opera in memoria e in CPU, dalla prima istruzione di codice all’ultima prevista dal programmatore. Tipici errori di runtime sono le divisioni per zero, i loop infiniti, le terminazioni anomale per mancanza o incongruenza delle risorse richieste dal programma, ecc…
Fase di messa a punto
Il runtime può anche essere avviato tramite un programma speciale, denominato debugger (attività di debugging).

TD nome.exe
In questo caso il debugger carica ed esegue il programma nelle modalità impostate dal programmatore, ad esempio passo passo (per verificare il flusso dell’esecuzione) o tramite breakpoint, ovvero sospensioni dell’esecuzione su istruzioni critiche, per esplorare lo stato di registri, variabili e memoria (watch). Tutto ciò al fine di individuare le cause di
eventuali malfunzionamenti riscontrati al runtime.

Please follow and like us:

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.

Commenti recenti

Working Hours

  • Monday9am - 6pm
  • Tuesday9am - 6pm
  • Wednesday9am - 6pm
  • Thursday9am - 6pm
  • Friday9am - 6pm
  • SaturdayClosed
  • SundayClosed
Latest Posts

Teachers

Facebook
Twitter
LinkedIn
Contatti

Commenti recenti

Wordpress Social Share Plugin powered by Ultimatelysocial
error

Enjoy this blog? Please spread the word :)

%d blogger hanno fatto clic su Mi Piace per questo: