Vinculador dinâmico

Na computação , um vinculador dinâmico é a parte de um sistema operacional que carrega e vincula as bibliotecas compartilhadas necessárias para um executável quando ele é executado (em " tempo de execução "), copiando o conteúdo das bibliotecas do armazenamento persistente para a RAM , preenchendo o salto tabelas e realocação de ponteiros . O sistema operacional específico e o formato executável determinam como o vinculador dinâmico funciona e como ele é implementado.

A vinculação costuma ser chamada de processo executado quando o executável é compilado , enquanto um vinculador dinâmico é uma parte especial de um sistema operacional que carrega bibliotecas compartilhadas externas em um processo em execução e, em seguida, vincula essas bibliotecas compartilhadas dinamicamente ao processo em execução. Essa abordagem também é chamada de vinculação dinâmica ou vinculação tardia .

Implementações

Microsoft Windows

Biblioteca de vínculo dinâmico , ou DLL, é a implementação da Microsoft do conceito de biblioteca compartilhada nos sistemas operacionais Microsoft Windows e OS/2 . Essas bibliotecas geralmente possuem a extensão de arquivo ( para bibliotecas contendo controles ActiveX ) ou (para drivers de sistema legados ). Os formatos de arquivo para DLLs são os mesmos dos arquivos EXE do Windows – ou seja, Executável Portátil (PE) para Windows de 32 e 64 bits e Novo Executável (NE) para Windows de 16 bits . Tal como acontece com os EXEs, as DLLs podem conter código , dados e recursos , em qualquer combinação. DLLOCXDRV

Arquivos de dados com o mesmo formato de arquivo de uma DLL, mas com extensões de arquivo diferentes e possivelmente contendo apenas seções de recursos, podem ser chamados de DLLs de recursos. Exemplos de tais DLLs incluem bibliotecas de interface de usuário multilíngue com extensão MUI, bibliotecas de íconesICL , às vezes com a extensão , e arquivos de fonteFON , com as extensões e FOT. [1]

Sistemas do tipo Unix usando ELF e sistemas baseados em Darwin

Na maioria dos sistemas do tipo Unix , a maior parte do código de máquina que compõe o vinculador dinâmico é na verdade um executável externo que o kernel do sistema operacional carrega e executa primeiro em um espaço de endereço de processo recém-construído como resultado de chamadas execou posix_spawnfunções. No momento do link, o caminho do vinculador dinâmico que deve ser usado é incorporado na imagem executável.

Quando um arquivo executável é carregado, o kernel do sistema operacional lê o caminho do vinculador dinâmico dele e então tenta carregar e executar esse outro binário executável; se essa tentativa falhar porque, por exemplo, não há nenhum arquivo com esse caminho, a tentativa de executar o executável original falhará. O vinculador dinâmico então carrega a imagem executável inicial e todas as bibliotecas vinculadas dinamicamente das quais ela depende e inicia o executável. Como resultado, o nome do caminho do vinculador dinâmico faz parte da interface binária do aplicativo do sistema operacional .

Sistemas usando ELF

Em sistemas do tipo Unix que usam ELF para imagens executáveis ​​e bibliotecas dinâmicas, como Solaris , versões de 64 bits do HP-UX , Linux , FreeBSD , NetBSD , OpenBSD e DragonFly BSD , o caminho do vinculador dinâmico que deve ser usado é incorporado no momento do link na .interpseção do segmento do executável PT_INTERP. Nesses sistemas, bibliotecas compartilhadas carregadas dinamicamente podem ser identificadas pelo sufixo do nome do arquivo .so(objeto compartilhado).

O vinculador dinâmico pode ser influenciado a modificar seu comportamento durante a execução ou a vinculação do programa, e os exemplos disso podem ser vistos nas páginas de manual do vinculador em tempo de execução para vários sistemas semelhantes ao Unix. [2] [3] [4] [5] [6] Uma modificação típica desse comportamento é o uso de LD_LIBRARY_PATHvariáveis ​​de LD_PRELOAD ambiente , que ajustam o processo de vinculação do tempo de execução, pesquisando bibliotecas compartilhadas em locais alternativos e forçando o carregamento e vinculação de bibliotecas que de outra forma não seria, respectivamente. Um exemplo é zlibc, [7] também conhecido como uncompress.so, [a] que facilita a descompressão transparente quando usado através do LD_PRELOAD hack ; conseqüentemente, é possível ler dados de arquivos pré-compactados (gzipados) em sistemas BSD e Linux como se os arquivos não estivessem compactados, essencialmente permitindo que um usuário adicione compactação transparente ao sistema de arquivos subjacente, embora com algumas ressalvas. O mecanismo é flexível, permitindo a adaptação trivial do mesmo código para realizar processamento adicional ou alternativo de dados durante a leitura do arquivo, antes do fornecimento dos referidos dados ao processo do usuário que os solicitou. [8] [9]

macOS e iOS

No sistema operacional Apple Darwin e nos sistemas operacionais macOS e iOS construídos sobre ele, o caminho do vinculador dinâmico que deve ser usado é incorporado no momento do link em um dos comandos de carregamento do Mach-O na imagem executável. Nesses sistemas, as bibliotecas compartilhadas carregadas dinamicamente podem ser identificadas pelo sufixo do nome do arquivo .dylibou pela sua colocação dentro do pacote configurável de uma estrutura.

O vinculador dinâmico não apenas vincula o executável de destino às bibliotecas compartilhadas, mas também coloca funções de código de máquina em pontos de endereço específicos na memória que o executável de destino conhece no momento do link. Quando um executável deseja interagir com o vinculador dinâmico, ele simplesmente executa a chamada específica da máquina ou a instrução de salto para um desses pontos de endereço bem conhecidos. Os executáveis ​​nas plataformas macOS e iOS geralmente interagem com o vinculador dinâmico durante a execução do processo; sabe-se até que um executável pode interagir com o vinculador dinâmico, fazendo com que ele carregue mais bibliotecas e resolva mais símbolos, horas após seu lançamento inicial. A razão pela qual um programa macOS ou iOS interage com o vinculador dinâmico com tanta frequência se deve às APIs Cocoa e Cocoa Touch da Apple e ao Objective-C , a linguagem na qual são implementadas (consulte seus artigos principais para obter mais informações).

O vinculador dinâmico pode ser coagido a modificar alguns de seus comportamentos; entretanto, diferentemente de outros sistemas operacionais do tipo Unix, essas modificações são dicas que podem ser (e às vezes são) ignoradas pelo vinculador dinâmico. Exemplos disso podem ser vistos na dyldpágina de manual do . [10] Uma modificação típica deste comportamento é o uso das variáveis ​​de ambiente DYLD_FRAMEWORK_PATHe DYLD_PRINT_LIBRARIES. A primeira das variáveis ​​mencionadas anteriormente ajusta o caminho de busca dos executáveis ​​para as bibliotecas compartilhadas, enquanto a última exibe os nomes das bibliotecas à medida que são carregadas e vinculadas.

O vinculador dinâmico macOS da Apple é um projeto de código aberto lançado como parte do Darwin e pode ser encontrado no dyldprojeto de código aberto da Apple. [11]

Sistemas semelhantes a Unix baseados em XCOFF

Em sistemas operacionais do tipo Unix que usam XCOFF , como AIX , bibliotecas compartilhadas carregadas dinamicamente usam o sufixo de nome de arquivo .a.

O vinculador dinâmico pode ser influenciado a modificar seu comportamento durante a execução ou a vinculação do programa. Uma modificação típica desse comportamento é o uso da LIBPATH variável de ambiente . Esta variável ajusta o processo de vinculação em tempo de execução, pesquisando bibliotecas compartilhadas em locais alternativos e forçando o carregamento e vinculação de bibliotecas que de outra forma não existiriam, respectivamente.

OS/360 e sucessores

A vinculação dinâmica de programas em linguagem Assembler no IBM OS/360 e seus sucessores é feita normalmente usando uma instrução de macro LINK contendo uma instrução Supervisor Call que ativa as rotinas do sistema operacional que disponibiliza o módulo da biblioteca a ser vinculado ao programa. Os módulos da biblioteca podem residir em um "STEPLIB" ou "JOBLIB" especificado em cartões de controle e disponíveis apenas para uma execução específica do programa, em uma biblioteca incluída no LINKLIST no PARMLIB (especificado na inicialização do sistema), ou no " link pack area" onde módulos reentrantes específicos são carregados no momento da inicialização do sistema.

Multics

No sistema operacional Multics todos os arquivos, incluindo os executáveis, são segmentos . Uma chamada a uma rotina que não faz parte do segmento atual fará com que o sistema encontre o segmento referenciado, na memória ou no disco, e o adicione ao espaço de endereço do processo em execução. A vinculação dinâmica é o método normal de operação, e a vinculação estática (usando o fichário ) é a exceção.

Eficiência

A vinculação dinâmica é geralmente mais lenta (requer mais ciclos de CPU) do que a vinculação durante o tempo de compilação, [12] como é o caso da maioria dos processos executados em tempo de execução. No entanto, a vinculação dinâmica costuma ser mais eficiente em termos de espaço (no disco e na memória em tempo de execução). Quando uma biblioteca é vinculada estaticamente, cada processo executado é vinculado à sua própria cópia das funções da biblioteca que estão sendo chamadas. Portanto, se uma biblioteca for chamada muitas vezes por programas diferentes, as mesmas funções dessa biblioteca serão duplicadas em vários locais da memória do sistema. Usar bibliotecas compartilhadas e dinâmicas significa que, em vez de vincular cada arquivo à sua própria cópia de uma biblioteca no momento da compilação e potencialmente desperdiçar espaço de memória, apenas uma cópia da biblioteca é armazenada na memória por vez, liberando espaço de memória para ser usado em outro lugar. [13] Além disso, na vinculação dinâmica, uma biblioteca só é carregada se estiver realmente sendo usada. [14]

Veja também

Notas

  1. ^ Não deve ser confundido com a biblioteca de compactação zlib .

Referências

  1. ^ Corporação Microsoft. "Criando uma DLL somente de recursos". Biblioteca da Rede de Desenvolvedores Microsoft .
  2. ^ ld.so.1(1) : Vinculador/carregador dinâmico do Solaris -  Manual de referência dos comandos do usuário do Solaris 11.4
  3. ^ ld-linux.so(8)  –  Manual do Programador Linux – Administração e Comandos Privilegiados
  4. ^ rtld(1) : Linker/carregador dinâmico do FreeBSD –  Manual de comandos gerais do FreeBSD
  5. ^ ld.elf_so(1) : Vinculador / carregador dinâmico NetBSD -  Manual de comandos gerais do NetBSD
  6. ^ ld.so(1) : Vinculador/carregador dinâmico OpenBSD –  Manual de comandos gerais do OpenBSD
  7. ^ “ZLIBC - Acesso transparente a arquivos compactados” . Arquivado do original em 04/06/2000.
  8. ^ "descompactar.so" . delorie. com . Recuperado em 04/07/2014 .
  9. ^ "zlibc.conf" . delorie. com . Recuperado em 04/07/2014 .
  10. ^ dyld(1) : Vinculador/carregador dinâmico Darwin/Mac OS X –  Manual de comandos gerais Darwin e macOS
  11. ^ Apple Inc. "Código Aberto - Lançamentos" . apple. com . Recuperado em 04/07/2014 .
  12. ^ Xuxian, Jiang (2009). "Princípios de sistemas operacionais: vinculação e carregamento" (PDF) . Universidade Estadual da Carolina do Norte . Recuperado em 24/09/2020 .
  13. ^ Jones, M. (28/08/2008). "Anatomia das bibliotecas dinâmicas do Linux". IBM . Recuperado em 24/09/2020 .
  14. ^ Sivilotti, Paul (agosto de 2012). "Link e carregamento dinâmico" (PDF) . Universidade Estadual de Ohio . Recuperado em 24/09/2020 .

Leitura adicional

  • Levine, John R. (2000) [outubro de 1999]. Ligadores e carregadores. A série Morgan Kaufmann em Engenharia e Programação de Software (1 ed.). São Francisco, EUA: Morgan Kaufmann . ISBN 1-55860-496-0. OCLC  42413382. Arquivado do original em 05/12/2012 . Recuperado em 12/01/2020 .Código: [1][2] Errata: [3]

links externos

  • Vinculação e carregamento dinâmicos, IECC.com
  • Vinculação dinâmica em Linux e Windows, parte um, Symantec.com
  • Anatomia das bibliotecas dinâmicas do Linux, IBM.com
Obtido em "https://en.wikipedia.org/w/index.php?title=Dynamic_linker&oldid=1125824017"