Compilação, Amarração e Relocação

Transcrição

1 Compilação, Amarração e Relocação Desenvolvimento modular Programas grandes devem ser implementados de forma modular Limitam a complexidade de manutenção do código Mudança em um módulo não requer a re-compilação de todo o programa Módulos comuns podem ser disponibilizados em bibliotecas Cada módulo: define uma coleção símbolos que representam tipos, constantes, variáveis e procedimentos, e referencia outros símbolos de outros módulos O compilador gera código objeto para cada módulo, e o amarrador (linker) junta os objetos em um executável.

2 O processo completo O driver de compilador (gcc) invoca cada uma das etapas: pré-processador (cpp), compilador(cc1), assembler (as) e linker(ld), para gerar o executável (para ver as etapas, use gcc v... ) m.c a.c ccp, cc1, as ccp, cc1, as m.o Linker (ld) a.o Arquivos objeto relocáveis (endereços relativos ao início do arquivo) p Arquivo objeto executável (com todos dados e procedimentos definidos em m.c and a.c) Obs: arquivos objeto (.o) não podem ser executados, pois há referências não resolvidas e os endereços não são os definitivos. Tarefas do processo de amarração (linker) 1. Combina vários arquivos objeto relocáveis (.o) em um único arquivo executável, que pode ser carregado na memória e executado; 2. Resolve todas as referências externas, isto é referências a um símbolo definido em outro arquivo objeto 3. Faz a relocação de todos os símbolos Transforma endereços relativos em endereços absolutos no executável Atualiza todas as referências para estes símbolos para refletir suas novas posições Obs: As referências podem ser para código ou dados Amarração poder ser feita em tempo de compilação (ld do Unix), tempo de carga ou de execução

3 Estrutura geral de um arquivo objeto Tabela de símbolos exportados Tabela de referências externas Código (.text) Dados incializados (.data) Exemplo: int x = 3; Dados não incializados Exemplo: int x; Dicionário de relocação (= tabela com as posições no código onde existe uma referência à memória) Informação para o depurador (debugger) Os formatos mais usados: ELF (Executable and Linkable Format) para sistemas Unix PE (Portable Executable) para Windows Formato ELF de arquivo objeto (1/2) Header ELF contém magic number, tipo (.o, exec,.so), arquitetura, big/little endian, etc. Tabela de header de programas (para executáveis) Contém tamanho de página (para memória virtual), segmentos e seus tamanhos.text código.data Dados inicializados státicos (*).bss section Dados não incializados státicos Não ocupa espaço ( Better Save Space ) ELF header Program header table (required for executables).text section.data section.bss section.symtab.rel.txt.rel.data.debug Section header table (required for relocatables) (*) Lembre-se que variáveis dinâmicas, no corpo de procedimentos, são alocados na pilha de execução 0

4 Formato ELF de arquivo objeto (2/2).symtab =Tabela de símbolos com: Nomes de procedimentos e variáveis estáticas Nomes de seções e posições.rel.text Informação de relocação para seção.text Endereços das instruções que precisarão ser modificados no executável.rel.data Informação de relocação para seção.data Endereços dos enderços (ponteiros para dados) que precisarão ser modificados no executável.debug Seção que relaciona posições no arquivo objeto com linhas do código fonte; para depuração (gcc -g) ELF header Program header table (required for executables).text section.data section.bss section.symtab.rel.text.rel.data.debug Section header table (required for relocatables) 0 Amarração (Linker) Principais tarefas (recapitulando) 1. combinar todos os objetos em um executável 2. Resolver as referências externas 3. Relocar as referências absolutas à memória Vejamos usando um exempo: m.c int e=7; a.c extern int e; int main() { int r = a(); exit(0); } int *ep=&e; int x=15; int y; int a() { return *ep+x+y; }

5 m.o a.o Combinação de todos os objetos em um executável Arquivos objeto relocáveis system code system data main() int e = 7 a() int *ep = &e int x = 15 int y.text.data.text.data.text.data.bss Arquivo executável 0 headers system code main() a() more system code system data int e = 7 int *ep = &e int x = 15 uninitialized data.symtab.debug A união requer a relocação dos endereços em cada módulo de forma a acrescentar sua posição dentro da concatenação.text.data.bss Def of local symbol e Resolução de referências Cada símbolo (entidade léxica) possui um valor (=seu endereço de memória). Referências podem ser locais ou externas. Ref to external symbol exit (defined in libc.so) m.c int e=7; int main() { int r = a(); exit(0); } Ref to external symbol a Def of local symbol ep a.c extern int e; int *ep=&e; int x=15; int y; int a() { return *ep+x+y; } Def of local symbol a Refs of local symbols ep,x,y Ref to external symbol e Defs of local symbols x and y

6 Resolução de referências Objetivo: associar cada referência externa a exatamente uma (1) definição do símbolo Usa a tabela de símbolo de cada módulo m que contém: Símbolos globais: definidos em m e que podem ser referenciados por outros módulos (funções e variáveis não definidos com static) Símbolos referenciados por m, mas definidos em outro módulo Símbolos locais: definfidos e referenciados exclusivamente por m (funções e variáveis definidos com static) Obs: as tabelas de símbolos são criadas pelo montador (as), usando os símbolos exportados na etapa de compilação. Resolução de referências Pode ser impossível: Se um símbolo referenciado não foi declarado Linker produz uma mensagem de erro ( undefined reference to foo ) Pode ser ambígua: se existem várias definições para o mesmo símbolo em diferentes módulos Linker usa o conceito de símbolo forte e fraco (variáveis incializadas VS não inicializadas) e as seguintes regras: R1: não permite definição de >1 símbolos fortes R2: se houver definição de 1 símbolo forte e vários fracos, escolha a definição forte R3: se só houver definições de símbolos fracos, escolha qualquer uma (de a cordo com a ordem dos módulos)

7 Exemplos Linker escolhe o x de foo3.c por ser forte, e resultado é x= 15212! Linker escolhe qualquer um dos x (ambos fracos) e resultado pode ser igualmente inesperado! Mais um erro de difícil detecção Linker escolhe o x de foo5.c por ser forte, mas agora x de bar5.c ocupa 8 bytes, e f() sobre escreve y! Resultado é x= 0x Para identificar possíveis conflitos use flag warn-common no gcc

8 Relocação É o processo (no ligador) de atribuir endereços de carga às várias partes do programa: Ajustando o código e dados (.text e.data) para refletir os endereços designados e Levando em conta os endereços dos símbolos definidos em outros módulos Na resolução de referências, as posições são calculadas com relação ao endereço 0 (zero), que seria o início do código. Quando a relocação é feita as posições de memória calculadas na etapa anterior funcionarão como distâncias (offsets) Informação de relocação de m.o m.c int e=7; int main() { int r = a(); exit(0); } Disassembly of section.text: <main>: <main>: 0: 55 pushl %ebp 1: 89 e5 movl %esp,%ebp 3: e8 fc ff ff ff call 4 <main+0x4> 4: R_386_PC32 a 8: 6a 00 pushl $0x0 a: e8 fc ff ff ff call b <main+0xb> b: R_386_PC32 exit f: 90 nop Disassembly of section.data: <e>: 0: source: objdump

9 Informação de Relocação de a.o (.text) a.c extern int e; Disassembly of section.text: <a>: 0: 55 pushl %ebp int *ep=&e; 1: 8b movl 0x0,%edx int x=15; 6: 00 int y; 3: R_386_32 ep 7: a movl 0x0,%eax int a() { 8: R_386_32 x c: 89 e5 movl %esp,%ebp return *ep+x+y; e: addl (%edx),%eax } 10: 89 ec movl %ebp,%esp 12: addl 0x0,%eax 17: 00 14: R_386_32 y 18: 5d popl %ebp 19: c3 ret Informação de Relocação de a.o (.data) a.c extern int e; Disassembly of section.data: int *ep=&e; int x=15; int y; int a() { return *ep+x+y; } <ep>: 0: <x>: 4: 0f : R_386_32 e

10 Executável depois de resolução de referência e relocação (.text) <main>: : 55 pushl %ebp : 89 e5 movl %esp,%ebp : e call <a> : 6a 00 pushl $0x a: e8 35 ff ff ff call <_init+0x94> f: 90 nop <a>: : 55 pushl %ebp : 8b 15 1c a0 04 movl 0x804a01c,%edx : : a1 20 a movl 0x804a020,%eax c: 89 e5 movl %esp,%ebp e: addl (%edx),%eax : 89 ec movl %ebp,%esp : d0 a3 04 addl 0x804a3d0,%eax : : 5d popl %ebp : c3 ret Seção de Dados em 0x804a... Bibliotecas Permitem agrupar módulos objeto relacionados em um arquivo No momento da ligação, apenas os módulos necessários são copiados e combinados com o executável Para resolução de referências, processa-se as bibliotecas da esquerda para a direita! gcc main.c mylib.a /usr/lib/libm.a Driver gcc já amarra automaticamente com libc.a Para criar uma biblioteca, basta listar os arquivos objeto relocáveis, por exemplo: ar rcs mylib.a addvector.o multvector.o

11 Bibliotecas estáticas (archives) p1.c p2.c compilação compilação p1.o p2.o libc.a Linker (ld) p Arquivo executável somente conterá código e dados de libc que são referenciadas em p1.c e p2.c Carga (loading) O ato de copiar algumas seções para o espaço de endereçamento do processo, naturalmente,fazendo-se a relocação. ELF header Program header table (required for executables).text section.data section.bss section.symtab.rel.text.rel.data.debug Section header table (required for relocatables) Process image init and shared lib segments.text segment (r/o).data segment (initialized r/w).bss segment (uninitialized r/w) Virtual addr 0x080483e0 0x x0804a010 0x0804a3b0

12 Bibliotecas dinâmicas e compartilhadas Principais desvantagens de bibliotecas estáticas: Replicação de código comum nos executáveis Desperdício de espaço em disco e na memória Qualquer modificação (correção) nas bibliotecas requer uma re-amarração (re-linking) de todas as aplicações que as usam Bibliotecas dinâmicas (ou dynamic link libraries, DLLs) os módulos são dinâmicamente carregados e ligados à aplicação em tempo de carga ou em tempo de execução Vantagem adicional: estas bibliotecas podem ser compartilhadas por vários processos. Bibliotecas Dinâmicas e compartilhadas m.c a.c (cc1, as) m.o (cc1,as) a.o Linker (ld) Executável parcialmente ligado (em disco) p libc.so Biblioteca dinâmica Executável totalmente ligado (em RAM) Loader/Dynamic Linker (ld-linux.so) P Funções de libc.so chamdas por m.c & a.c são carregadas, ligadas, e compartilhadas entre vários processos.