C Como os computadores gera os executável

Edinho-013 · 26 de novembro de 2020

Ola, tudo bem!

Alguem pode me explica como o compiladores gerar os códigos executável? .exe por exemplo.

Ja que minha última ideia era aprender a programa em hex code (codigo em hexadecimal, dos executável), mas nao é uma solução viável para o meu projeto de um compilador. alguém pode me ajudar a entender o processo de geração de codigo?

arfneto · 26 de novembro de 2020

1 hora atrás, Edinho-013 disse:

Alguem pode me explica como o compiladores gerar os códigos executável?

Eu te expliquei isso já no seu outro post. Compiladores não geram código executável. O LINK gera, o ld no Linux gera.

1 hora atrás, Edinho-013 disse:

Ja que minha última ideia era aprender a programa em hex code

Não estaria programando em "hex code". Todo arquivo no computador é digital, binário. Pode ser visto em hexadecimal, em octal como é o padrão histórico de C, em decimal ou qualquer base que prefira. Só estaria entrando com um arquivo bit a bit digitando os valores em um editor de texto, só que ao invés de digitar os opcodes como usaria em assembler ou os comandos de alguma linguagem, e depois passar pelo ciclo normal de compile/link estaria digitando o programa direto com os códigos.

Isso não tem qualquer finalidade prática. Não vai aprender nada. E do modo como são os sistemas hoje em dia vai precisar de milhares de "instruções" para um programa de uma linha. E se imagina que vai "entrar com um código na unha sem depender de ninguém" esqueça. Os sistemas desde os anos 70 são altamente cooperativos e precisa chamar dezenas de funções do sistema antes de sequer iniciar seu programa.

Esse programa em C no SUSE linux com gcc 7.5 tem mais de 12.000 bytes

#include "stdio.h"
int main(void)
{
    printf("Hello World\n!");
    return 0;
}

Veja o código gerado usando gcc -S

	.file	"minimo.c"
	.text
	.section	.rodata
.LC0:
	.string	"Hello World\n!"
	.text
	.globl	main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movl	$.LC0, %edi
	movl	$0, %eax
	call	printf
	movl	$0, %eax
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (SUSE Linux) 7.5.0"
	.section	.note.GNU-stack,"",@progbits

E só isso levou a mais de 12.000 bytes que você iria digitar um por um. Recomendo esquecer a ideia.

Edinho-013 · 26 de novembro de 2020

@arfneto

Sim, esse é o problema!

Meu projeto é de um compilador (para estudos) e o back end gera um codigo em assembly onde tenho que usar o nasm para gerar os arquivos executaveis. Dai vem um problema se eu mandar para um amigo e ele nao tiver o nasm nao poderá executar o codigo. Então fui pesquisar sobre o assunto, dai encontrei o formato PE (Portable Executable) mas é inviável tentar aprender os opcodes e escrever em um arquivo exe ou elf.

Até porque cada um segue uma estrutura como cabeçalho .... além do numero de bytes que terar que escrever. Então agora estou procurando uma solução de gerar os executável de forma mais simples e viável. Por exemplo depois das etapas da compilação (análise lexica, sintática e semântica) chega a hora de gerar o executável mas como? Ja que usar o nasm para montar os arquivos objetos e depois fazer a link edição e por fim um arquivo executável o meu problema ira continuar, e tentar escrever os bytes em um arquivo exe é inviável.

Como consigo embutir um linker ja pronto

arfneto · 26 de novembro de 2020

14 minutos atrás, Edinho-013 disse:

Então agora estou procurando uma solução de gerar os executável de forma mais simples e viável

Isso vem sendo feito há décadas. Acha que vai fazer algo mais simples e viável do que o Unix e o Windows por exemplo tem desde os '80?

Sem ser original, crie uns op-codes e uma máquina virtual que roda seus programas, como o P-Code dos anos '70 no USCD pSystem. Ou algo que rode na JVM que possa rodar em outras máquinas, como é em java de todo modo. Ou como é o managed code no Windows