Binary Translation

Cambio di architettura

Problemi E il vecchio software?

Costo di produzione software (tempo e denaro)

Soluzioni Compilare il vecchio sorgente con nuovi compilatori Compilare il vecchio sorgente con nuovi compilatori Emulazione hardware Emulazione hardware Emulazione/interpretazione software Emulazione/interpretazione software Binary translation Binary translation

Binary translation Nessuna ricompilazione Nessuna ricompilazione

Binary translation Nessuna ricompilazione Nessuna ricompilazione Indipendenza dal sorgente Indipendenza dal sorgente

Binary translation Nessuna ricompilazione Nessuna ricompilazione Indipendenza dal sorgente Indipendenza dal sorgente Risparmio di tempo Risparmio di tempo

Binary translation Nessuna ricompilazione Nessuna ricompilazione Indipendenza dal sorgente Indipendenza dal sorgente Risparmio di tempo Risparmio di tempo Ottimizzazione Ottimizzazione

Binary translation Nessuna ricompilazione Nessuna ricompilazione Indipendenza dal sorgente Indipendenza dal sorgente Risparmio di tempo Risparmio di tempo Ottimizzazione Ottimizzazione Risparmio sui test Risparmio sui test

Binary translation Nessuna ricompilazione Nessuna ricompilazione Indipendenza dal sorgente Indipendenza dal sorgente Risparmio di tempo Risparmio di tempo Ottimizzazione Ottimizzazione Risparmio sui test Risparmio sui test Nessun disagio per gli utenti Nessun disagio per gli utenti

Binary translation Nessuna ricompilazione Nessuna ricompilazione Indipendenza dal sorgente Indipendenza dal sorgente Risparmio di tempo Risparmio di tempo Ottimizzazione Ottimizzazione Risparmio sui test Risparmio sui test Nessun disagio per gli utenti Nessun disagio per gli utenti Distribuzione multipiattaforma Distribuzione multipiattaforma

Difficoltà Simili a disassembler e decompilers Simili a disassembler e decompilers Problema della terminazione Problema della terminazione Problema nella staticità Problema nella staticità

Decompilation

Decompilazione (MikeVanEmmerik ) ProblemaDecompilatoreDecompilatore assembler Disassemblatore ideale Decompilato re bytecode Separare codice e dati sinosino Separare codici e costanti sinosifacile Recuperare parametri ecc. si no Analisi dei tipisi nosolo locali Dichiarare datisi banale Fondere istruzioni si nosi Salti strutturati, condizionali si nosi

Esempio: dcc void main () { int loc1; int loc2; int loc3; int loc4; printf ("Input number of iterations: "); printf ("Input number of iterations: "); scanf ("%d", &loc1); scanf ("%d", &loc1); loc3 = 1; loc3 = 1; while ((loc3 <= loc1)) { while ((loc3 <= loc1)) { printf ("Input number:"); printf ("Input number:"); scanf ("%d", &loc2); scanf ("%d", &loc2); loc4 = proc_1 (loc2); loc4 = proc_1 (loc2); printf ("fibonacci(%d) = %u\n", loc2, loc4); printf ("fibonacci(%d) = %u\n", loc2, loc4); loc3 = (loc3 + 1); loc3 = (loc3 + 1); } /* end of while */ } /* end of while */ exit(0); exit(0);}

Esempio: REC main() { /* unknown */ void ebx; /* unknown */ void esi; /* unknown */ void ebx; /* unknown */ void esi; /* unknown */ void Vfffffffc; /* unknown */ void Vfffffffc; (save)"Input number: "; (save)"Input number: "; printf(); printf(); (save) & Vfffffffc; (save)"%d"; scanf(); (save) & Vfffffffc; (save)"%d"; scanf(); ebx = Vfffffffc; ebx = Vfffffffc; esp = esp + 12; esp = esp + 12; if(ebx > 1) { if(ebx > 1) { esi = fib(ebx - 1); esi = fib(ebx - 1); eax = fib(ebx - 2) + esi; eax = fib(ebx - 2) + esi; } else { } else { eax = ebx; eax = ebx; } printf("fibonacci(%d) = %d\n", Vfffffffc, eax); printf("fibonacci(%d) = %d\n", Vfffffffc, eax); esp = ebp - 12; esp = ebp - 12; return(0); return(0);}

Esempio: Boomerang Esempio di codice: int somma(int a, int b) { return a + b; return a + b;} int main() { printf("%i\n", somma(3, 4)); printf("%i\n", somma(3, 4));} Output di The Boomerang: void main() { int local0; int local0; local0 = proc1(3, 4) ; local0 = proc1(3, 4) ; local0 = printf("%i\n", local0) ; local0 = printf("%i\n", local0) ; return ; return ;} int proc1(int arg1, int arg2) { return arg2+arg1; return arg2+arg1;}

Static binary translation

Dynamic binary translation

Retargetable binary translator

MIMIC (Ibm 1987) Emulatore Emulatore IBM System/370  IBM RT PC IBM System/370  IBM RT PC Tecniche di caching Tecniche di caching Fattore di espansione 1:4 (non 1:100) Fattore di espansione 1:4 (non 1:100)

Accelerator (Tandem 1992) Traduttore binario Traduttore binario TNS CISC  TNS RISC TNS CISC  TNS RISC 1% di interpretazione 1% di interpretazione Codice tradotto più veloce (5-8X) Codice tradotto più veloce (5-8X)

Flashport (AT&T 1994) Set generale di piattaforme Set generale di piattaforme Intervento utente Intervento utente Da una settimana a sei mesi di computazione Da una settimana a sei mesi di computazione

Tibbit (1995) Motorola  IBM RS/6000, AIX 3.2 Motorola  IBM RS/6000, AIX 3.2 Traduzione applicazioni real-time tra processori con velocità differenti Traduzione applicazioni real-time tra processori con velocità differenti

Digital (anni 90) VAX, MIPS, SPARC  Alpha VAX, MIPS, SPARC  Alpha VEST, Freeport express VEST, Freeport express Ore di computazione Ore di computazione

FX!32 (Digital 1996) Ibrido: emulatore/binary translator Ibrido: emulatore/binary translator WinNT(32bit) x86  WinNT(64bit) Alpha WinNT(32bit) x86  WinNT(64bit) Alpha

NJMC (1999) New Jersey Machine-Code Toolkit New Jersey Machine-Code Toolkit Indipendente dalla macchina Indipendente dalla macchina Aiuta a scrivere parsers e debuggers Aiuta a scrivere parsers e debuggers Introduce il Register Transfer Language (RTL) Introduce il Register Transfer Language (RTL)

Disassembler, generazione 1-2 Dcc: 860 linee in più giorni Dcc: 860 linee in più giorni NJMC: 208 linee in poche ore NJMC: 208 linee in poche ore

Aries (HP, 2000) PA-RISC  ia64 PA-RISC  ia64 all user-level applications all user-level applications

Futuro

Futuro

Futuro

Futuro

Futuro Cindy Zheng Carol Thompson Aries (PA-RISC/ia64)

Futuro Cindy Zheng Carol Thompson Aries (PA-RISC/ia64) HP-UX WOW64

Futuro Actually, being able to run IA-32 code on IA-64 HP-UX machines is not a primary goal for HP. Instead, it is a positive side effect of a software partitioning solution that HP is developing to allow multiple operating systems to share CPUs and other resources. IA-64 will never execute 32-bit code as well as a dedicated processor

Bibliografia (1) Libri: "Compilers - Principles, Techniques and Tools", Aho, Sethi, Ullman, "Compilers - Principles, Techniques and Tools", Aho, Sethi, Ullman, "Advanced Compiler Design & Implementation", Steven Muchnick "Advanced Compiler Design & Implementation", Steven Muchnick "How debuggers work - Algorithms, Data Structures, and Architecture", Jonathan Rosemberg "How debuggers work - Algorithms, Data Structures, and Architecture", Jonathan Rosemberg “A Conceptual Foundation for Software Re-Engineering”,E. J. Byrne “A Conceptual Foundation for Software Re-Engineering”,E. J. ByrneLinks:

Bibliografia (2) “Transparent Execution, No Recompilation”Cindy Zheng Carol Thompson “Transparent Execution, No Recompilation”Cindy Zheng Carol Thompson “Running IA-32 Code on IA-64” by Christophe de Dinechin “Running IA-32 Code on IA-64” by Christophe de Dinechin “Binary Translation: Static, Dynamic, Retargetable?*”, C. Cifuentes, V. Malhotra “Binary Translation: Static, Dynamic, Retargetable?*”, C. Cifuentes, V. Malhotra