Esempi di sviluppo ed elaborazione di programmi in C + Assembly

Architettura degli elaboratori 2016-17, 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 sottoptogramma 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.txt .
• 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 direcory.
• 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-13.1, nios2-16.1}, <i> ∊ {1, 2}.

  N.B. i sorgenti nelle due directory per il processore Nios-II sono identici, gli script differiscono per la diversità del path di collocazione della Nios2EDS suite inclusa in due diverse versioni del software Quartus e dei rispettivi eseguibili.

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 dei primi cinque passi della precedente, mediante esecuzione degli script omonimi per la seconda variante dell'esempio.

Se si vuole eseguire una sessione interattiva di esecuzione controllata dal debugger gdb, occorre preliminarmente modificare lo script di compilazione (./script/gcctestBCDpacksub) per aggiungere l'opzione -g, come nell'omonimo script della prima variante: tale opzione di gcc genera, nell'eseguibile, i simboli di debugging necessari all'esecuzione controllata dal debugger. Può poi essere utile consultare i comandi dati in input al debugger nell'esempio precedente, nel file ../ex1/script/gdbtestBCDpacksub.gdb, da adattare all'esecuzione di un programma diverso, che ha simboli diversi.

3 Esempi in cap04extra/arm, cap04extra/nios2-13.1, cap04extra/nios2-16.1

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, 2016/2017 .
Autore: G. Scollo .
Data: Giovedì 18 Maggio 2017
testo semplice di questa pagina.