O que você vê ao usar Debug + Windows + Disassembly ao depurar um programa C # é um bom guia para esses termos. Aqui está uma versão anotada dele quando compilo um programa 'hello world' escrito em C # na configuração da versão com a otimização JIT habilitada:
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
Clique com o botão direito na janela e marque "Mostrar bytes de código" para obter uma exibição semelhante.
A coluna à esquerda é o endereço do código da máquina. Seu valor é falsificado pelo depurador, o código está realmente localizado em outro lugar. Mas isso pode ser em qualquer lugar, dependendo do local selecionado pelo compilador JIT, então o depurador apenas começa a numerar os endereços de 0 no início do método.
A segunda coluna é o código da máquina . Os reais 1s e 0s que a CPU executa. O código de máquina, como aqui, é comumente exibido em hexadecimal. Talvez seja ilustrativo que 0x8B seleciona a instrução MOV, os bytes adicionais estão lá para dizer à CPU exatamente o que precisa ser movido. Observe também os dois sabores da instrução CALL, 0xE8 é a chamada direta, 0xFF é a instrução de chamada indireta.
A terceira coluna é o código de montagem . Assembly é uma linguagem simples, projetada para tornar mais fácil escrever código de máquina. Ele se compara ao C # sendo compilado para IL. O compilador usado para traduzir o código assembly é chamado de "assembler". Você provavelmente tem o Microsoft assembler em sua máquina, seu nome executável é ml.exe, ml64.exe para a versão de 64 bits. Existem duas versões comuns de linguagens assembly em uso. O que você vê é aquele que a Intel e a AMD usam. No mundo do código aberto, a montagem na notação AT&T é comum. A sintaxe da linguagem é fortemente dependente do tipo de CPU para a qual foi escrito, a linguagem assembly para um PowerPC é muito diferente.
Ok, isso aborda dois dos termos em sua pergunta. "Código nativo" é um termo difuso, não é incomum para descrever o código em uma linguagem não gerenciada. Talvez seja instrutivo ver que tipo de código de máquina é gerado por um compilador C. Esta é a versão 'hello world' em 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
Eu não anotei, principalmente porque é muito semelhante ao código de máquina gerado pelo programa C #. A chamada da função printf () é bem diferente da chamada Console.WriteLine (), mas todo o resto é quase o mesmo. Observe também que o depurador agora está gerando o endereço do código de máquina real e que é um pouco mais inteligente sobre os símbolos. Um efeito colateral da geração de informações de depuração após gerar código de máquina, como costuma acontecer com os compiladores não gerenciados. Devo também mencionar que desativei algumas opções de otimização de código de máquina para fazer o código de máquina parecer semelhante. Os compiladores C / C ++ têm muito mais tempo disponível para otimizar o código; o resultado costuma ser difícil de interpretar. E muito difícil de depurar.
O ponto principal aqui é que há muito poucas diferenças entre o código de máquina gerado a partir de uma linguagem gerenciada pelo compilador JIT e o código de máquina gerado por um compilador de código nativo. Essa é a principal razão pela qual a linguagem C # pode ser competitiva com um compilador de código nativo. A única diferença real entre eles são as chamadas de função de suporte. Muitos dos quais são implementados no CLR. E isso gira principalmente em torno do coletor de lixo.