Quello che vedi quando usi Debug + Windows + Disassembly durante il debug di un programma C # è una buona guida per questi termini. Ecco una versione annotata di esso quando compilo un programma 'hello world' scritto in C # nella configurazione di rilascio con l'ottimizzazione JIT abilitata:
static void Main(string[] args) {
Console.WriteLine("Hello world");
00000000 55 push ebp ; save stack frame pointer
00000001 8B EC mov ebp,esp ; setup current frame
00000003 E8 30 BE 03 6F call 6F03BE38 ; Console.Out property getter
00000008 8B C8 mov ecx,eax ; setup "this"
0000000a 8B 15 88 20 BD 02 mov edx,dword ptr ds:[02BD2088h] ; arg = "Hello world"
00000010 8B 01 mov eax,dword ptr [ecx] ; TextWriter reference
00000012 FF 90 D8 00 00 00 call dword ptr [eax+000000D8h] ; TextWriter.WriteLine()
00000018 5D pop ebp ; restore stack frame pointer
}
00000019 C3 ret ; done, return
Fare clic con il pulsante destro del mouse sulla finestra e selezionare "Mostra byte di codice" per ottenere una visualizzazione simile.
La colonna a sinistra è l'indirizzo del codice macchina. Il suo valore è falsificato dal debugger, il codice si trova effettivamente da qualche altra parte. Ma potrebbe essere ovunque, a seconda della posizione selezionata dal compilatore JIT, quindi il debugger inizia a numerare gli indirizzi da 0 all'inizio del metodo.
La seconda colonna è il codice macchina . Gli 1 e gli 0 effettivi eseguiti dalla CPU. Il codice macchina, come qui, è comunemente visualizzato in esadecimale. Forse è illustrativo che 0x8B seleziona l'istruzione MOV, i byte aggiuntivi sono lì per dire alla CPU esattamente cosa deve essere spostato. Notare anche i due tipi di istruzione CALL, 0xE8 è la chiamata diretta, 0xFF è l'istruzione di chiamata indiretta.
La terza colonna è il codice assembly . L'assembly è un linguaggio semplice, progettato per semplificare la scrittura del codice macchina. Si confronta con C # compilato in IL. Il compilatore utilizzato per tradurre il codice assembly è chiamato "assembler". Probabilmente hai l'assembler Microsoft sulla tua macchina, il suo nome eseguibile è ml.exe, ml64.exe per la versione a 64 bit. Esistono due versioni comuni dei linguaggi assembly in uso. Quello che vedi è quello che Intel e AMD usano. Nel mondo open source, l'assemblaggio nella notazione AT&T è comune. La sintassi del linguaggio dipende fortemente dal tipo di CPU per cui è stato scritto, il linguaggio assembly per un PowerPC è molto diverso.
Ok, questo affronta due dei termini della tua domanda. "Codice nativo" è un termine sfocato, non è usato di rado per descrivere il codice in un linguaggio non gestito. Forse è istruttivo vedere che tipo di codice macchina viene generato da un compilatore C. Questa è la versione 'ciao mondo' in C:
int _tmain(int argc, _TCHAR* argv[])
{
00401010 55 push ebp
00401011 8B EC mov ebp,esp
printf("Hello world");
00401013 68 6C 6C 45 00 push offset ___xt_z+128h (456C6Ch)
00401018 E8 13 00 00 00 call printf (401030h)
0040101D 83 C4 04 add esp,4
return 0;
00401020 33 C0 xor eax,eax
}
00401022 5D pop ebp
00401023 C3 ret
Non l'ho annotato, soprattutto perché è così simile al codice macchina generato dal programma C #. La chiamata alla funzione printf () è abbastanza diversa dalla chiamata Console.WriteLine () ma tutto il resto è più o meno lo stesso. Si noti inoltre che il debugger sta ora generando l'indirizzo del codice macchina reale e che è un po 'più intelligente sui simboli. Un effetto collaterale della generazione di informazioni di debug dopo la generazione di codice macchina come spesso fanno i compilatori non gestiti. Devo anche menzionare che ho disattivato alcune opzioni di ottimizzazione del codice macchina per rendere il codice macchina simile. I compilatori C / C ++ hanno molto più tempo a disposizione per ottimizzare il codice, il risultato è spesso difficile da interpretare. E molto difficile da eseguire il debug.
Punto chiave qui è che ci sono molto poche differenze tra codice macchina generato da un linguaggio gestito dal codice compilatore JIT e la macchina generato da un compilatore di codice nativo. Questo è il motivo principale per cui il linguaggio C # può essere competitivo con un compilatore di codice nativo. L'unica vera differenza tra loro sono le chiamate alla funzione di supporto. Molti dei quali sono implementati nel CLR. E questo ruota principalmente attorno al netturbino.