Esempi di sviluppo ed elaborazione di programmi in C + Assembly

Architettura degli elaboratori 2017-18, CdL Informatica, DMI, Univ. Catania

1. Esempi in cap04extra

• programma per architettura a 32 bit (elaborabile anche su piattaforma a 64 bit se dotata delle necessarie librerie)
• sorgenti: programma principale in C, sottoprogramma in Assembly
• due varianti dell'esempio:
  1. ex1: un solo sottoprogramma Assembly
  2. ex2: il sottoprogramma Assembly chiama un altro sottoprogramma Assembly
• architetture: IA-32, ARMv7, Nios-II
• 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 utilità, librerie e documentazione degli strumenti usati per ciascuna delle tre architetture sono indicati nel file ToolChainDoc .
• funzioni dei moduli di programma:
  • sottoprogramma: compressione di una sequenza di cifre decimali da codice ASCII (una cifra per byte) a BCD (due cifre per byte)
  • programma principale: collaudo del sottoprogramma con una sequenza predefinita in un array di costanti e visualizzazione della sequenza ottenuta in ritorno
• script ausiliari: l'esecuzione del processo di elaborazione dei sorgenti è facilitata da alcuni script, che però 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 è uno shell script e dunque non acquisisce permessi di esecuzione dal comando indicato sopra: è un file di comandi al debugger, attivato dallo shell script gdbtestBCDpacksub nella stessa directory.
• 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 lì 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 è come quella indicata per il primo esempio, previo posizionamento nella directory <arch>/ex<i> appropriata.

Architettura degli elaboratori, 2017/2018, Esercitazione 08 .
Autore: G. Scollo .
Data: Domenica 20 Maggio 2018
testo semplice di questa pagina.