G. Frosini – Programmazione mista Slide 1

Presentazione sul tema: "G. Frosini – Programmazione mista Slide 1"— Transcript della presentazione:

1 G. Frosini – Programmazione mista Slide 1

2 Caratteristiche del processore PC
Processore PC (Processore Completo): processore didattico; schematizzazione (software compatibile) dei processori a 32 bit della famiglia INTEL, funzionanti in modo protetto (x86-32); costituito da 2 unità di elaborazione visibili al programmatore: la ALU (Aritmetic and Logic Unit), che esegue le istruzioni generali, quelle sui numeri naturali e interi; la FPU (Floating Point Unit), che esegue le istruzioni sui numeri reali. Operandi manipolati dalle istruzioni della ALU: lunghi 8 bit (byte), 16 bit (parola) o 32 bit (parola lunga). Operandi manipolati dalle istruzioni della FPU: lunghi 80 bit. G. Frosini – Programmazione mista Slide 2

3 Spazi di indirizzamento
Funzionamento del Processore PC: senza memoria virtuale; con memoria virtuale paginata. Spazio di memoria senza memoria virtuale: lineare, e costituito da 2**32 locazioni di un byte, il cui indirizzo va da 0x a 0xFFFFFFFF. Spazio di memoria con memoria virtuale paginata: come sopra Spazio di I/O (sempre senza memoria virtuale): lineare; costituito da 2**16 porte da un byte, il cui indirizzo va da 0x0000 a 0xFFFF. G. Frosini – Programmazione mista Slide 3

4 G. Frosini – Programmazione mista Slide 4
Registri (1) EAX EBX ECX EDX SI DI BP SP EIP EFLAG AX (AH, AL) BX (BH, BL) CX (CH, CL) DX (DH, DL) ESI EDI EBP ESP Registri generali Registri di stato ALU FPU ST Altri G. Frosini – Programmazione mista Slide 4

5 G. Frosini – Programmazione mista Slide 5
Registri (2) Registri generali della ALU (32 bit): possono venir indifferentemente utilizzati o per memorizzare operandi o per contenere indirizzi di memoria. Alcuni di essi svolgono specifiche funzioni: registri ESP, EBP: servono a indirizzare la pila; ESP funge da puntatore alla cima della pila. EBP funge da registro base per una zona della pila; registri EAX, EDX: EAX funge principalmente da accumulatore ed EDX da estensione dell'accumulatore; registri ESI, EDI: fungono principalmente da registri indice; Registri generali della FPU (80 bit): organizzati a pila; il registro di testa della pila si chiama ST. G. Frosini – Programmazione mista Slide 5

6 G. Frosini – Programmazione mista Slide 6
Registri (3) Registro di stato EIP (ALU): contiene l'indirizzo della prossima istruzione. Registro di stato EFLAG (ALU): costituito da due parti, ciascuna di 2 byte; la parte meno significativa contiene: i flag aritmetici PF (Parity), ZF (zero), CF (Carry), SF (Sign), OF (Overflow); i flag IF e TF relativi al meccanismo di interruzione; il flag DF utilizzato dalle istruzioni sulle stringhe. 15 CF PF ZF SF TF IF DF OF 2 4 6 8 10 7 9 11 G. Frosini – Programmazione mista Slide 6

7 Codifica delle istruzioni
I-prefix (prefisso di istruzione): viene utilizzato per le istruzioni che operano sulle stringhe (REP, REPE, REPNE). O-prefix (prefisso di lunghezza): indica che la lunghezza degli operandi è di una parola, ogni qual volta il campo OC specifica una parola lunga. OC (Operation Code): specifica il codice operativo e la lunghezza degli operandi (byte o parola lunga). MODE e SIB (Scaled Index Base): indicano il modo di reperire gli operandi e il fattore di scala. DISP (DISplacement): contiene lo spiazzamento. IMM (IMMediate): contiene l'operando immediato. G. Frosini – Programmazione mista Slide 7

8 Indirizzamenti per le istruzioni operative
Indirizzamento di registro: operando in un registro del processore. Indirizzamento immediato: operando nell’istruzione (campo IMM). Indirizzamento di memoria (una o due componenti possono mancare): indirizzo = | base + indice*scala + spiazzamento | modulo 2**32 base è il contenuto di uno dei registri generali; indice è il contenuto di uno dei registri generali; scala è un fattore che può valere 1, 2, 4 oppure 8; spiazzamento è un numero intero a 8 bit o a 32 bit, contenuto nel campo DISP. G. Frosini – Programmazione mista Slide 8

9 Indirizzamento di memoria
Dalla forma generale derivano i seguenti indirizzamenti: diretto: è presente solamente lo spiazzamento; indiretto: è indicato solamente il registro base; modificato con registro base: sono indicati il registro base e lo spiazzamento (utilizzato per riferire le componenti di una struttura); modificato con registro indice e scala: sono indicati il registro indice, la scala e lo spiazzamento (utilizzato per riferire le componenti di un vettore); bimodificato senza spiazzamento: sono indicati un registro base ed un registro indice (con scala); bimodificato con spiazzamento: sono indicati un registro base, un registro indice (con scala) e lo spiazzamento. G. Frosini – Programmazione mista Slide 9

10 Indirizzamenti per le istruzioni di controllo
Indirizzo di salto: viene ottenuto nel modo seguente (indirizzamento relativo): indirizzo = | EIP + spiazzamento | modulo 2**32 spiazzamento è un numero intero, di 8 bit o di 32 bit, contenuto nel campo DISP; il salto può avvenire a indirizzi maggiori o a indirizzi minori rispetto a EIP. G. Frosini – Programmazione mista Slide 10

11 Indirizzamenti per le istruzioni di I/O
Indirizzo dalla porta: può essere specificato nell'istruzione (indirizzamento diretto, detto impropriamente immediato); può essere contenuto nel registro DX (indirizzamento indiretto, detto impropriamente di registro). Prima forma: possibile solo per indirizzi minori di 256. G. Frosini – Programmazione mista Slide 11

12 G. Frosini – Programmazione mista Slide 12
AMBIENTE GCC Ambiente di programmazione utilizzato: GCC (GNU Compiler Collection); collezione di software di sviluppo del sistema GNU; contiene l’Assemblatore, il Compilatore C e il Compilatore C++; può essere utilizzato su un calcolatore con sistema operativo Unix e processore INTEL x86-32 o x86-64; un calcolatore che ha un processore x86-64, con opzioni appropriate, può operare anche su file sorgenti contenenti codice relativo a un processore INTE x86-32 e generare file eseguibili da un processore INTEL x86-32. Programma eseguibile prodotto: un file eseguibile prodotto per un processore INTEL x86-32 può essere eseguito anche da un calcolatore con sistema operativo Unix e processore INTEL x86-64. Nel seguito, considereremo sempre file sorgenti con codice per un processore INTEL x86-32; file sorgenti contenenti codice Assembler sono legati al processore x86-32; file sorgenti contenenti codice C o codice C++ sono indipendenti dal processore utilizzato. G. Frosini – Programmazione mista Slide 12

13 Assembler GCC per il processore PC (1)
Forma di un’istruzione Assembler: etichetta: codice-operativo sorgente, destinatario etichetta, sorgente, destinatario: possono mancare. Simbologia: codice operativo: specifica l’operazione e la lunghezza degli operandi (b: byte; w: parola; l: parola lunga); %: deve essere messo prima del nome di un registro; $ deve essere messo prima di un operando immediato. Etichetta: lettere minuscole o lettere maiuscole sono differenti. Codice operativo, nome di un registro: lettere minuscole o lettere maiuscole sono equivalenti. G. Frosini – Programmazione mista Slide 13

14 Assembler GCC per il processore PC (2)
Istruzioni operative con indirizzamento di memoria: indirizzo di memoria: displacement( base, indice, scala) MOVL displacement(%EBP, %ESI, 4), %EAX MOVL (%EBP, %ESI, 4), %EAX MOVL displacement(, %ESI, 4), %EAX MOVL displacement(%EBP), %EAX MOVL (,%ESI, 4), %EAX MOVL (%EBP), %EAX MOVL displacement, %EAX displacement: può essere un numero intero, un’etichetta, un’espressione; scala: numero naturale che può valere 1, 2, 4 o 8: se vale 1, può essere omesso. G. Frosini – Programmazione mista Slide 14

15 Assembler GCC per il processore PC (3)
Istruzioni di salto: JMP etichetta JZ etichetta Istruzioni di I/O: INB %DX, %AL INB $25, %AL G. Frosini – Programmazione mista Slide 15

16 Assembler GCC per il processore PC (4)
Pseudo-istruzioni (iniziano con .): .BYTE valore # numero naturale o intero, o letterale carattere .WORD valore .LONG valore .FLOAT valore .DOUBLE valore .QUAD valore .SPACE numero-byte .FILL numero-componenti, numero-byte-per-componente .ASCII letterale stringa … Direttive (iniziano anch’esse con .): .TEXT .DATA .ALIGN n # allineamento a indirizzo multipli di n, potenza di 2 .INCLUDE "nome file" # nome del file da includere, con eventuale percorso …. G. Frosini – Programmazione mista Slide 16

17 Programma Assembler (1)
costituito da due sezioni, una sezione dati e una sezione testo; memorizzato su uno o più file, ciascuno detto file sorgente. in ogni file, sono presenti nessuna, una o più parti della sezione dati (pseudoistruzione .DATA), e nessuna, una o più parti della sezione testo (pseudoistruzione .TEXT) Inizio del programma: etichetta _start, che deve essere dichiarata globale (direttiva .GLOBAL). Fine del programma: risultato per il Sistema Operativo: va eventualmente lasciato nel registro ebx; quando vale 0, tutto si è svolto correttamente; quando è diverso da 0, il valore costituisce la codifica di un errore; Sistema operativo Unix: il valore di ritorno precedente (utilizzando il linguaggio di script bash) è visibile attraverso la variabile $? (comando per vederne il valore: echo $?). Istruzioni di ritorno: MOVL …, %EBX MOVL $1, %EAX # numero d’ordine della primitiva Unix exit INT $0x80 G. Frosini – Programmazione mista Slide 17

18 Programma Assembler (2)
.DATA ... dati .TEXT # sottoprogramma sottop: RET # programma principale .GLOBAL _start _start: … CALL sottop … MOVL …, %EBX MOVL $1, %EAX INT $0x80 G. Frosini – Programmazione mista Slide 18

19 Sviluppo di un programma Assembler con calcolatore x86-64 (1)
Un file sorgente: deve avere estensione s; viene tradotto separatamente dagli altri, dando luogo a un nuovo file, il file oggetto (estensione o). Traduzione: avviene attraverso il programma Assemblatore; comando: as nomefile.s –o nomefile.o File oggetto ottenuti dalle traduzioni: devono essere collegati insieme per formare un unico file eseguibile (senza estensione); programma eseguibile contenuto nel file: viene costruito a partire da un indirizzo prestabilito. G. Frosini – Programmazione mista Slide 19

20 Sviluppo di un programma Assembler con calcolatore x86-64 (2)
Collegamento: avviene attraverso il programma Collegatore o Linker; comando: ld –melf_i386 nomefile1.o …. nomefilen.o –o nomefile l’opzione –o nomefile può essere omessa, ed in questo caso il nome del file eseguibile è per default a.out (non esiste l’estensione: tutti i caratteri presenti costituiscono il nome del file). File eseguibile: viene caricato in memoria, a partire da un indirizzo di caricamento effettivamente disponibile; viene eventualmente rilocato (modificato), per tener conto di questa nuova posizione, in genere diversa da quella per cui è stato predisposto. G. Frosini – Programmazione mista Slide 20

21 Sviluppo di un programma Assembler con calcolatore x86-64 (3)
Caricamento e rilocazione: avvengono per mezzo del programma Caricatore o Loader. comando: ./nomefile Escuzione: il Caricatore: inizializza il puntatore di pila: pone in pila il valore del nuovo contatore di programma (corrispondente all'etichetta _start); esegue l’ istruzione RET. Programma costituito da un solo file: viene sviluppato secondo le fasi sopra elencate; il collegamento viene comunque effettuato, eventualmente con alcuni programmi di libreria, già tradotti una volta per tutte. G. Frosini – Programmazione mista Slide 21

22 Calcolatore con processore x86-32
Comandi di traduzione e di collegamento precedenti: non si deve utilizzare l’opzione –32 (comando as) e l’opzione –melf_i386 (comando ld). Comando di esecuzione precedente: Valido anche in questo caso Nel seguito: useremo i comandi per un calcolatore con Sistema Operativo Unix e processore x86-64. G. Frosini – Programmazione mista Slide 22

23 Rappresentazione grafica
G. Frosini – Programmazione mista Slide 23

24 G. Frosini – Programmazione mista Slide 24
File ser.s Contiene due sottoprogrammi tastiera e video: tastiera: legge il successivo carattere battuto a tastiera e pone il suo codice ASCII nel registro AL; video: scrive su video il carattere il cui codice ASCII è contenuto in AL; tastiera e video utilizzano il servizio Unix 0x80 (opportuni parametri in EAX, EBX, ECX). Contiene una routine uscita: restituisce il controllo al Sistema Operativo; è composta dalle istruzioni (ipotesi: non ci sono stati errori): uscita: MOVL $0, %EBX MOVL $1, %EAX INT $0x80 Sottoprogrammi tastiera e video: effettuano ingresso/uscita a linee (I/O bufferizzato) ; i caratteri battuti a tastiera compaiono in eco su video e vengono effettivamente letti quando viene premuto il tasto ENTER; in lettura, ENTER viene riconosciuto come carattere '\n'; i caratteri inviati su video vengono visualizzati quando viene inviato il carattere '\n' (nuova linea); viene automaticamente inserito anche il carattere '\r' (ritorno carrello). G. Frosini – Programmazione mista Slide 24

25 G. Frosini – Programmazione mista Slide 25
Programma codifica (1) # File codifica.s .GLOBAL _start .DATA kappa: .FILL 8, 1 .TEXT .INCLUDE "ser.s" _start: ancora: CALL tastiera CMPB $'\n', %AL # carattere nuova linea JE fine CALL video # carattere in AL MOVB %AL, %BL MOVB $' ', %AL # carattere spazio CALL video G. Frosini – Programmazione mista Slide 25

26 G. Frosini – Programmazione mista Slide 26
Programma codifica (2) MOVB $0, %CL # cl funge da contatore ciclo: TESTB $0x80, %BL # esame del bit piu’ significativo di BL JZ zero MOVB $'1', %AL CALL video JMP avanti zero: MOVB $'0', %AL avanti: SHLB $1, %BL # traslazione sinistra di BL INCB %CL CMPB $8, %CL JB ciclo MOVB $'\n', %AL # carattere nuova riga JMP ancora fine: JMP uscita G. Frosini – Programmazione mista Slide 26

27 G. Frosini – Programmazione mista Slide 27
Programma codifica (3) File precedente: deve essere prima tradotto; il file tradotto deve essere poi collegato. Questo si ottiene con i comandi: as --32 codifica.s -o codifica.o ld –melf_i386 codifica.o -o codifica Il file eseguibile (codifica) può essere caricato e mandato in esecuzione con il comando: ./codifica G. Frosini – Programmazione mista Slide 27

28 Nomi esterni e nomi globali (o pubblici)
In un file si possono utilizzare nomi (o identificatori) definiti in altri file: tali nomi vanno dichiarati esterni. Nomi esterni: si dichiarano utilizzando la direttiva .EXTERN: .EXTERN nome, ... Alcuni nomi (o identificatori) definiti in un file possono essere utilizzati da altri file: tali nomi vanno dichiarati globali (o pubblici). Nomi globali: si dichiarano utilizzando la direttiva .GLOBAL: .GLOBAL nome, ... G. Frosini – Programmazione mista Slide 28

29 G. Frosini – Programmazione mista Slide 29
Punto di inizio File sorgente Assembler: contiene uno spezzone di programma, che può prevedere il punto di inizio (entry_point) dell’intero programma (simbolo _start). File principale: contiene l’entry_point; ne deve esistere uno e uno solo. File secondari: altri file. Situazione comune: il file principale contiene dati e il programma principale con alcuni sottoprogrammi, mentre un file secondario contiene solo dati e sottoprogrammi. Indirizzo iniziale (_start): dichiarato globale, per renderlo visibile al Caricatore (consentendo al Caricatore l’inizializzazione del registro EIP con tale indirizzo). In un file, i nomi non globali sono propri di quel file: uno stesso nome può essere utilizzato in file diversi e identifica entità diverse. G. Frosini – Programmazione mista Slide 29

30 G. Frosini – Programmazione mista Slide 30
Programma codifica1 (1) Programma codifica1: due file: il primo contiene il programma principale, il secondo il sottoprogramma esamina, utilizzato dal primo file. Programma principale: legge caratteri fino al fine linea; per ogni carattere, lo stampa, richiama il sottoprogramma esamina, quindi stampa il risultato. Sottoprogramma esamina: restituisce otto caratteri, corrispondenti ai bit della codifica del carattere ricevuto. Trasmissione dei dati fra programma e sottoprogramma: due variabili alfa e beta definite nel secondo file (esterne nel primo file e globali nel secondo); alfa: contiene il codice del carattere, beta: contiene l'indirizzo della variabile risultato. il programma principale pone i dati in alfa e beta, quindi chiama esamina. G. Frosini – Programmazione mista Slide 30

31 G. Frosini – Programmazione mista Slide 31
Programma codifica1 (2) # PROGRAMMA codifica1 # File principale codifica1a.s .EXTERN alfa, beta, esamina .GLOBAL _start .DATA kappa: .FILL 8, 1 .TEXT .INCLUDE "ser.s" _start: ancora: CALL tastiera CMPB $'\n', %AL JE fine CALL video MOVB %AL, %BL MOVB $' ', %AL MOVB %BL, alfa MOVL $kappa, beta CALL esamina MOVL $0, %ESI ripeti: MOVB kappa(%ESI), %AL CALL video INCL %ESI CMPL $8, %ESI JB ripeti MOVB $'\n', %AL JMP ancora fine: JMP uscita G. Frosini – Programmazione mista Slide 31

32 G. Frosini – Programmazione mista Slide 32
Programma codifica1 (3) # PROGRAMMA codifica1 # File secondario codifica1b.s .GLOBAL alfa, beta, esamina .DATA alfa: .BYTE 0 beta: .LONG 0 .TEXT esamina: PUSHL %EAX PUSHL %EBX PUSHL %ESI MOVB alfa, %AL # I dato MOVL beta, %EBX # II dato MOVL $0, %ESI ciclo: TESTB $0x80, %AL JZ zero MOVB $'1', (%EBX, %ESI) JMP avanti zero: MOVB $'0', (%EBX, %ESI) avanti: SHLB $1, %AL INCL %ESI CMPL $8, %ESI JB ciclo POPL %ESI POPL %EBX POPL %EAX RET G. Frosini – Programmazione mista Slide 32

33 G. Frosini – Programmazione mista Slide 33
Programma codifica1 (4) File precedenti: devono essere prima tradotti; i file tradotti devono essere poi collegati. Questo si ottiene con i comandi: as --32 codifica1a.s -o codifica1a.o as --32 codifica1b.s -o codifica1b.o ld –melf_i386 codifica1a.o codifica1b.o -o codifica1 Il file eseguibile (codifica1) può essere caricato e mandato in esecuzione con il comando: ./codifica1 G. Frosini – Programmazione mista Slide 33

34 G. Frosini – Programmazione mista Slide 34
Comando g++ (1) Il comando: g++ -m32 nomefile1.s … nomefileN.s –o nomefile richiama singolarmente l’Assemblatore per i file nomefile1.s, …, nomefileN.s, producendo N file oggetto; richiama il Collegatore per gli N file precedenti e alcuni file dei libreria, producendo il file eseguibile nomefile; l’opzione –o nomefile può essere omessa, ed in questo caso il nome del file eseguibile è a.out Uno dei file di libreria collegati: contiene l’entry_point _start (nome definito globale); richiama il sottoprogramma main() (nome esterno); il sottoprogramma main() produce un risultato intero che deve essere lasciato in %EAX; al ritorno dal main(), restituisce il controllo al Sistema Operativo con le istruzioni: MOVL %EAX, %EBX MOVL $1, %EAX INT $0x80 Comando g++: per calcolatori con processore a 32 bit, non occorre l’opzione –m32. G. Frosini – Programmazione mista Slide 34

35 G. Frosini – Programmazione mista Slide 35
Comando g++ (2) Organizzazione del file principale: .EXTERN …. .GLOBAL main, … .DATA … .TEXT .INCLUDE "servizio.s" main: … XORL %EAX, %EAX RET Uso del comando g++: vengono collegati anche file di libreria C++, compresi quelli relativi alle funzionalità di I/O del C++. Nuovo file di servizio: file servizio.s: contiene alcuni sottoprogrammi Assembler per effettuare letture e scritture, che utilizzano le funzionalità di I/O del C++. G. Frosini – Programmazione mista Slide 35

36 G. Frosini – Programmazione mista Slide 36
File servizio.s (1) Scritture su video (I/O bufferizzato): - scrivicarattere: scrive su video il carattere la cui codifica ASCII si trova in AL; - scrivinaturale: converte il naturale espresso in base due contenuto in EAX in una sequenza di caratteri che rappresentano cifre in base sedici, e invia tale sequenza su video; - scriviintero: converte l’intero espresso in base due contenuto in EAX in una sequenza di caratteri che rappresentano il numero intero in base dieci, e invia tale sequenza su video; - scrivireale: converte il reale contenuto in ST, espresso con mantissa e caratteristica in base due, in una sequenza di caratteri che rappresentano il numero reale in base dieci, e invia tale sequenza su video; - scrivispazio: invia su video il carattere spazio; - nuovalinea: invia su video il caratteri '\n' (viene automaticamente aggiunto il carattere '\r' ); G. Frosini – Programmazione mista Slide 36

37 G. Frosini – Programmazione mista Slide 37
File servizio.s (2) Letture da tastiera (I/O bufferizzato): - leggisuccessivo: legge da tastiera il successivo carattere (anche uno spazio bianco) e pone la sua codifica ASCII in AL; - leggicarattere: salta eventuali spazi bianchi, legge da tastiera il successivo carattere diverso da spazio bianco e pone la sua codifica ASCII in AL; - legginaturale: salta eventuali spazi bianchi, legge da tastiera una sequenza di caratteri cifra in base sedici (che termina con il carattere spazio), la converte in un naturale in base due e lo pone in EAX; - leggiintero: salta eventuali caratteri bianchi, legge da tastiera un eventuale carattere segno e una sequenza di caratteri cifra in base dieci (che termina con il carattere spazio), la converte in un intero binario e lo pone in EAX. - leggireale: salta eventuali caratteri bianchi, legge da tastiera un eventuale carattere segno e una sequenza di caratteri che rappresenta un numero reale in base dieci (che termina con il carattere spazio), la converte in un reale con mantissa e caratteristica binarie e lo pone in ST. G. Frosini – Programmazione mista Slide 37

38 G. Frosini – Programmazione mista Slide 38
Programma codifica2 (1) # PROGRAMMA codifica2 # File principale codifica2a.s .EXTERN alfa, beta, esamina .GLOBAL main .DATA kappa: .FILL 8, 1 .TEXT .INCLUDE "servizio.s" main: ancora: CALL leggisuccessivo CMPB $'\n', %AL JE fine CALL scrivicarattere CALL scrivispazio MOVB %AL, alfa MOVL $kappa, beta CALL esamina MOVL $0, %ESI ripeti: MOVB kappa(%ESI), %AL CALL scrivicarattere INCL %ESI CMPL $8, %ESI JB ripeti CALL nuovalinea JMP ancora fine: XORL %EAX, %EAX RET G. Frosini – Programmazione mista Slide 38

39 G. Frosini – Programmazione mista Slide 39
Programma codifica2 (2) # PROGRAMMA codifica2 # File secondario codifica2b.s # uguale al file secondario codifica1b.s .GLOBAL alfa, beta, esamina .DATA alfa: .BYTE 0 beta: .LONG 0 .TEXT esamina: PUSHL %EAX … RET Sviluppo ed esecuzione del programma: g++ -m32 codifica2a.s codifica2b.s –o codifica2 ./codifica2 G. Frosini – Programmazione mista Slide 39

40 Programmi C++ su più file
Semplici regole di collegamento: in un file, i nomi delle variabili definite fuori delle funzioni e nomi di funzioni: sono implicitamente globali; possono essere riferite da altri file. in un file si possono riferire nomi definiti in altri file purché: vengano dichiarati esterni; siano globali nei file dove sono definiti. Dichiarazioni di nomi esterni: extern int var; // variabile extern void fun(int par1,…, int parn); // funzione extern void fun(int,…, int); G. Frosini – Programmazione mista Slide 40

41 Programma codifica3 (in C++) (1)
// File principale codifica3a.cpp using namespace std; #include <iostream> extern char alfa; extern char* beta; extern void esamina(); char kappa[8]; int main() { char al; for(;;) { cin.get(al); if (al == '\n') break; cout << al ; alfa = al; beta = &kappa[0]; // anche beta = kappa; esamina(); cout << ' '; for (int i=0; i<8; i++) cout << kappa[i]; cout << endl; }; return 0; } G. Frosini – Programmazione mista Slide 41

42 Programma codifica3 (in C++) (2)
// File secondario codifica3b.cpp using namespace std; // non necessario char alfa; char* beta; void esamina() { for(int i = 0; i < 8; i++) { if ((alfa & 0x80) == 0) *(beta+i) = '0'; else *(beta+i) = '1'; // anche beta[i] alfa = alfa<<1; } Sviluppo ed esecuzione del programma: g++ -m32 codifica3a.cpp codifica3b.cpp -o codifica3 ./codifica3 G. Frosini – Programmazione mista Slide 42

43 G. Frosini – Programmazione mista Slide 43
Programmi misti (1) Programma GCC organizzato su più file: può essere scritto utilizzando linguaggi differenti per i vari file; ciascun file viene tradotto con il proprio traduttore, e tutti i traduttori producono file oggetto della stessa forma; viene utilizzato un unico collegatore, che produce il programma eseguibile. GCC, comando g++: richiama singolarmente i traduttori per i vari file; file con estensione c: richiama il Compilatore C; file con estensione cc o cpp: richiama il compilatore C++; i compilatori producono file Assembler, con estensione s; file con estensione s, compresi quelli generati nei punti precedenti: richiama l’Assemblatore, che produce file con estensione o; richiama il collegatore, inserendo anche file di libreria. G. Frosini – Programmazione mista Slide 43

44 Programmi misti (2) Compilatori C/C++: Intero programma:
inseriscono le variabili globali, con i loro nomi nella sezione dati; inseriscono le funzioni, con nomi appropriati, nella sezione testo; i parametri e le variabili locali delle funzioni vengono manipolati per mezzo della pila. Intero programma: consistente solo se i differenti linguaggi utilizzati: fanno uso della stessa modalità di rappresentare dati; utilizzano nomi compatibili; utilizzano lo stesso standard per l'aggancio con i sottoprogrammi. Linguaggio C++ e Assembler: i file Assembler dovranno utilizzare lo standard proprio del compilatore C++.

45 G. Frosini – Programmazione mista Slide 45
Nomi C e nomi C++ Nomi di variabili globali e di funzioni C: sono uguali ai nomi Assembler. Nomi di variabili globali C++: come per il C. Nomi di funzioni C++: corrispondono a nomi Assembler ottenuti secondo regole complesse, che tengono conto del numero, del tipo e dell’ordine degli argomenti formali; assicurano la possibilità di avere overloading; possono essere uguali ai nomi Assembler (avere la corrispondenza del C), purché si usi la dichiarazione extern "C". Ipotesi: al momento, per i nomi di funzione utilizzeremo la corrispondenza C (rinunciando ad avere overloading); esamineremo in un secondo momento, per i nomi di funzione, la corrispondenza secondo le regole C++. G. Frosini – Programmazione mista Slide 45

46 Nomi esterni e globali C++ compatibili con nomi C
Nomi esterni, definiti in un altro file e utilizzati in un file C++: variabile: extern int var; funzione: extern "C" void fun(); Nomi globali, definiti in un file C++ e utilizzati in un altro file: deve essere globale; funzione (sempre globale): extern "C" void fun() { // … } La funzione main() definita in C++ è implicitamente extern "C". Attenzione! una funzione definita in C++ può modificare i registri. G. Frosini – Programmazione mista Slide 46

47 G. Frosini – Programmazione mista Slide 47
Dati in C/C++ Elaboratori basati sul processore x86-32: variabile di tipo int: 4 byte, in complemento a 2; variabili di tipo double: 8 byte, con 1 bit di segno, 11 bit di esponente in traslazione, e 52 bit di mantissa; variabili di tipo bool: un byte, con valore 0 equivalente a false e valore 1 equivalente a true; variabili di tipo char: un byte, in codifica ASCII (con il bit più significativo uguale a 0); variabili di un tipo enumerato: un intero, il cui valore è dato dal numero d’ordine dell’enumeratore (identificatore), a partire da 0; variabili di un tipo puntatore: 4 byte (indirizzo di memoria). G. Frosini – Programmazione mista Slide 47

48 Programma misto codifica4 (1)
// Programma codifica4 // File principale codifica4a.cpp using namespace std; #include <iostream> extern char alfa; extern char* beta; extern "C" void esamina(); // unica differenza rispetto al file codifica3a.cpp char k[8]; int main() { char al; for(;;) { cin.get(al); if (al == '\n') break; cout << al ; alfa = al; beta = &k[0]; // anche beta = k; esamina(); cout << ' '; for (int i=0; i<8; i++) cout << k[i]; cout << endl; }; return 0; } G. Frosini – Programmazione mista Slide 48

49 Programma misto codifica4 (2)
# PROGRAMMA codifica4 # File secondario codifica4b.s, uguale al file codifica2b.s .GLOBAL alfa, beta, esamina .DATA alfa: .BYTE 0 beta: .LONG 0 .TEXT esamina: PUSHL %EAX … RET G. Frosini – Programmazione mista Slide 49

50 Programma misto codifica5 (1)
# PROGRAMMA codifica5 # File principale codifica5a.s, uguale al file codifica2a.s .EXTERN alfa, beta, esamina .GLOBAL main .DATA kappa: .FILL 8, 1 .TEXT .INCLUDE "servizio.s" main: ancora: CALL leggisuccessivo … fine: XORL %EAX, %EAX RET G. Frosini – Programmazione mista Slide 50

51 Programma misto codifica5 (2)
// PROGRAMMA codifica5 // File secondario codifica5b.cpp using namespace std; // non necessario char alfa; char* beta; extern "C" void esamina() // unica differenza rispetto al file codifica3b.cpp { for(int i = 0; i < 8; i++) { if ((alfa & 0x80) == 0) *(beta+i) = '0'; else *(beta+i) = '1'; // anche beta[i] alfa = alfa<<1; } G. Frosini – Programmazione mista Slide 51

52 Sviluppo delle versioni miste 4 e 5
Sviluppo della versione 4 g++ -m32 codifica4a.cpp codifica4b.s –o codifica4 ./codifica4 Sviluppo della versione 5: g++ -m32 codifica5a.s codifica5b.cpp –o codifica5 ./codifica5 G. Frosini – Programmazione mista Slide 52

53 OPZIONI DEL COMANDO g++
con l’opzione -nostdlib non collega nessun file di libreria (solo quelli esplicitamente elencati); in questo caso: non può più essere utilizzato il file servizio.s, ma solo il file ser.s; il programma principale deve avere la struttura vista per il comando as: # programma principale .TEXT #include ser.s .GLOBAL _start _start: … … MOVL $0, %EBX MOVL $1, %EAX INT $0x80 G. Frosini – Programmazione mista Slide 53