Esempi di sviluppo ed elaborazione di programmi in C + Assembly
 Architettura degli elaboratori 2018-19, CdL Informatica, DMI, Univ. Catania

  * 1.  Esempi in cap04extra *

 o  programma per architettura a 32 bit (elaborabile anche su 
    piattaforma a 64 bit se dotata delle necessarie librerie) 

 o  sorgenti: programma principale in C, sottoprogramma in Assembly

 o  due varianti dell'esempio:
     1. ex1: un solo sottoprogramma Assembly
     2. ex2: il sottoprogramma Assembly chiama un altro sottoprogramma Assembly 

 o  architetture: IA-32, ARMv7, Nios-II

 o  contenuti: sorgenti e shell script per l'elaborazione del programma 
    con compilatore gcc in s.o. Unix/Linux (collaudati su Ubuntu 16.04); 
    (cross-)compilatori, programmi di utilita`, librerie e documentazione 
    degli strumenti usati per ciascuna delle tre architetture sono 
    indicati nel file _ToolChainDoc_, URL: ./ToolChainDoc.html

 o  funzioni dei moduli di programma:

     o  sottoprogramma: compressione di una sequenza di cifre decimali 
        da codice ASCII (una cifra per byte) a BCD (due cifre per byte)

     o  programma principale: collaudo del sottoprogramma con una sequenza 
        predefinita in un array di costanti e visualizzazione della 
        sequenza ottenuta in ritorno 

 o  script ausiliari: l'esecuzione del processo di elaborazione dei 
    sorgenti e` facilitata da alcuni script, che pero` vanno dotati 
    del permesso di esecuzione dopo la decompressione dell'archivio; 
    e.g. su Unix/Linux:

       cd cap04extra
       chmod 755 */*/script/*BCDpacksub

    *N.B.* il file gdbtestBCDpacksub.gdb, presente nella directory 
    ia32/ex1/script, _non_ e` uno shell script e dunque non acquisisce 
    permessi di esecuzione dal comando indicato sopra: e` un file di 
    comandi al debugger, attivato dallo shell script gdbtestBCDpacksub 
    nella stessa directory.

 o  esecuzione degli script: documentata appresso per le due varianti 
    dell'esempio in ciascuna delle tre architetture; in ciascun caso, 
    posizionarsi nella directory <arch>/ex<i> ed eseguire da li` gli 
    script come indicato appresso; l'esecuzione degli script produce 
    i rispettivi file di output nella directory <arch>/ex<i>/tryout, 
    dove <arch> ∊ {ia32, arm, nios2}, <i> ∊ {1, 2}.


  * 2  Esempi in cap04extra/ia32 *

  * 2.1  Esempio in cap04extra/ia32/ex1 *

  Sequenza di elaborazione: 

 1. assemblaggio del sottoprogramma --> modulo oggetto
 2. compilazione del programma principale e collegamento con il 
    modulo oggetto del sottoprogramma --> programma eseguibile
 3. disassemblaggio del modulo oggetto del sottoprogramma
 4. disassemblaggio dell'eseguibile (sezioni .text e dati, header, simboli) 
 5. esecuzione del programma --> output ridiretto su file di testo
 6. sessione di esecuzione controllata dal debugger gdb

  rispettivamente mediante gli script: 

   ./script/asBCDpacksub
   ./script/gcctestBCDpacksub
   ./script/odBCDpacksub
   ./script/odtestBCDpacksub
   ./script/runtestBCDpacksub
   ./script/gdbtestBCDpacksub

  * 2.2  Esempio in cap04extra/ia32/ex2 *

  Sequenza di elaborazione identica a quella precedente, mediante 
esecuzione degli script omonimi per la seconda variante dell'esempio.


  * 3  Esempi in cap04extra/arm e cap04extra/nios2 *

  Allo stato attuale, su macchine di architettura x86 o amd gli esempi ia32 
sono riproducibili fino all'esecuzione e al debugging, mentre gli altri 
constano solo dei primi quattro passi della sequenza di elaborazione 
indicata per il primo esempio. L'esecuzione degli script per tali passi 
e` come quella indicata per il primo esempio, previo posizionamento nella 
directory <arch>/ex<i> appropriata.

--

   _Architettura degli elaboratori, 2018/2019, Esercitazione 08_
   URL: ../../ae_e08/it/ae_e08.html
   Autore: _G. Scollo_                URL: http://www.dmi.unict.it/~scollo
   Data: Martedi` 30 Aprile 2019
   _testo semplice_ di questa pagina  URL: ./README.txt