10. software de sistema - carrega- dorese...

DCA-FEEC-UNICAMP: Introdução à Computação Digital - 2009 - Prof. Léo Pini Magalhães 492

10. Software de Sistema - Carrega-

dores e Ligadores

Referências:

• Introdução à Compilação (capítulo 7)‏Ivan L. M. Ricarte

• Editora Campus-Elsevier, 2008

• ISBN 85-352-3067-X


Carregadores e Ligadores

CarregadoresMontadorCompiladores

Sistema Operacional(Gerenciador de Processador, Memória, E/S, etc)‏

Microprogramas

Circuitos Físicos

LigadoresProcessadorde Macro

Depuradores

ProgramasUtilitários

Programasde Aplicação

UsuárioSoftwareAplicativo

SoftwaredeSistema

Hardware


No capítulo anterior foi apresentado o programa montador.

Ao final da execução do montador já foi carregado diretamente na memória o programa do usuário (em linguagem de máquina) a ser executado.

O esquema usual de processamento éapresentado na próxima transparência.


10.1 Módulo Objeto

• artefato produzido pelo montador• última etapa do processo de tradução

• contém a informação necessária para que o programa venha a ser executado• no mínimo, o código de máquina

Devemos notar que, para fim de um melhor entendimento do Programa Montador, no capítulo 9 foi feita a simplificação do Programa Montador gerar diretamente o PLM (Programa em Linguagem de Máquina). Esta é uma das possibilidades (ver 10.2.a).


Conteúdo do módulo objeto

Tipicamente contendo a seguinte informação:

Cabeçalho: identificação do tipo de arquivo e dados sobre tamanho do código e arquivo-fonte que deu origem ao módulo

Código: instruções e dados em formato binário

Relocação: posições no código binário que devem ter conteúdo alterado de acordo com a posição de carregamento na memória

Símbolos: símbolos globais definidos no módulo e símbolos cujas definições virão de outros módulos (ligação)‏

Depuração: referências para o código fonte, tais como o número de linha, nomes originais dos símbolos locais e estruturas de dados definidas


Informação que é gerada pelo montador depende muito da forma como o módulo objeto éutilizado

Algumas possibilidades

a - montagem e carregamento combinados

b - carregamento absoluto

c - carregamento com ajuste de referências

Formato do módulo objeto


10.2 Esquemas de carregamento

• esquema de montagem é com endereço absoluto

• programador é responsável por definir endereços de memória principal nos quais código e dados serão carregados para execução

• ao invés de gerar um módulo objeto em um arquivo em disco, neste caso o código gerado pelo montador jáé escrito diretamente na sua posição de memória

• ao encerrar a montagem, montador transfere a execução (JUMP) para o início do código da aplicação

a) Montagem e carregamento combinados(esquema utilizado no capítulo 9)‏


Desvantagens

• responsabilidade do programador de manter endereços

• programa montador ocupa memória que poderia ser usada na execução do programa de aplicação

• cada execução demanda nova montagem, mesmo que nenhuma alteração tenha ocorrido

a) Montagem e carregamento combinados(esquema utilizado no capítulo 9)‏




• esquema de montagem também com endereçamento absoluto

• montagem e carregamento em momentos distintos• montador cria módulo objeto em disco

• carregador transfere módulo objeto do disco para a memória principal

• carregador e montador são programas separados

• módulo objeto deve conter informação para sua operação

b) Carregamento absoluto



Conteúdo do módulo objeto

• módulo objeto deve conter informação sobre endereço de memória principal no qual deve ser carregado

• um registro para cada segmento contíguo de código

• um outro tipo de registro contém o endereço de início de execução

• controle da execução é transferido para esse endereço ao final do carregamento





Relação Montador x Carregador Absoluto

O programa Montador gera um arquivo para ser trabalhado pelo programa Carregador Absoluto com o seguinte formato de campos:

• campo 1: tipo (0-texto; 1-fim)‏

• campo 2: endereço de carregamento

• campo 3: comprimento em bytes

• campo 4: conteúdo binário (em hexadecimal)‏


Fluxograma de um Carregador Absoluto




Exemplo:

DATA: EQU $6000PROG: EQU $4000

ORG DATAVALUE: DS.W 1RESULT: DS.W 1

ORG PROGPGM: MOVE.W VALUE, D0

MOVE.W DO, RESULTRTSEND PROG




CP Código

DATA: EQU $6000 0000

PROG: EQU $4000 0000

ORG DATA 0000

VALUE: DS.W 1 6000 0000

RESULT: DS.W 1 6002 0000

ORG PROG 6004

PGM: MOVE.W VALUE, D0 4000 30386000

MOVE.W DO, RESULT 4004 31C06002

RTS 4008 4E75

END PROG 400A

valor do CP após cada iteração do montador passo 2




Exemplo Montador

0 6000 4 00 00 00 00

0 4000 A 30 38 60 00 31 C0 60 02 4E 75

1 4000

Carregador Absoluto

código na memória




Limitações

• programador é responsável por manter o registro de endereços• por exemplo, localização na memória de

variáveis e subrotinas• não há flexibilidade para execução do código

• caso as posições de memória não estejam disponíveis, programa não pode ser carregado e assim executado



c) Carregamento com ajuste a referências

Este carregador procura superar limitações do carregador absoluto como a seguir:

1. não fixando endereços na programação• referências relativas ao início do código

2. é responsabilidade do carregador encontrar espaço de memória para o carregamento

• após definida a posição de carregamento, cabe ao carregador realizar a transferência e os ajustes nas referências




Tipos de ajuste

Relocação - referências que são resolvidas com o conhecimento da posição inicial do próprio segmento.

• ajuste interno ao segmento de programa

Ligação - referências que demandam conhecimento da posição inicial de outros segmentos para resolução

• ajuste entre segmentos distintos do programa

O módulo objeto deve agregar informação suficiente para que esses ajustes possam ser realizados.




Informações para ajustes: (ESD e RLD) ‏

• referência externa – símbolo é usado no presente segmento, mas definido em outro

• definição local – símbolo definido no presente segmento, mas pode ser referenciado em outros

• Dicionário de Símbolos Externos (ESD) ‏

• Símbolos que necessitam ser conhecidos entre segmentos de programas para resolução de referências: LD e SD.

• LD: definição local – símbolo definido no presente segmento, mas pode ser referenciado em outros

• SD: usado para definir segmento




Informações para ajustes: (ESD e RLD) ‏

• Diretório de Relocação e Ligação (RLD) ‏

• definição das posições de memória que necessitam de ajuste em relação a:

• valores de símbolos externos

• valor da posição inicial do próprio segmento




Formato usado para o Módulo Objeto

O módulo objeto usará registros de quatro tipos:

ESD - informação sobre nome do símbolo, sua posição relativa no segmento e sua dimensão em bytes

TXT - dimensão e o código de máquina do segmentoRLD - posição relativa e dimensão das referências que precisam ser

ajustadas no código de máquina. Qual valor (símbolo) usado como base para esse ajuste (símbolo-base)

END – indica o fim de um segmento e, caso este segmento contenha o programa principal, indica também o endereço de início de sua execução




Formato dos registros:

ESD.nome-símbolo.tipo-símbolo.endereço-relativo.comprimento

onde: tipo-símbolo é LD ou SD (ver transparência 511) ‏

comprimento é em bytes

TXT.endereço-relativo.comprimento.código-em-hexadeximal

RLD.endereço-relativo.comprimento.nome-símbolo-base

END.endereço-de-execução

endereço-de-execução é vazio se não for o segmento principal.


10.3 Exemplo de código gerado por montador

para futuro ajuste a referências

MAIN MOVE.B DIGIT, D0

CMPI.B #10, D0

BLT ADD_0

ADD.B #(´A´ - ´0´-10), D0

ADD_0 ADDI.B # ´0´, D0

MOVE.B D0, CHAR

RTS

CHAR DS.W 1

END MAIN

GLOB DIGIT

PGM MOVE.W VALUE, D0

MOVE.W D0, DIGIT

RTS

VALUE DS.W 1

DIGIT DS.W 1

END

Programa fonte para um processador Motorola da família 68000

Segmento MAIN Segmento PGM


Para MAIN: ESD.´MAIN´.´SD´.0000.001C

TXT.00.6.103900000000

TXT.06.4.0C00000A

TXT.0A.2.6D02

TXT.0C.2.5E00

TXT.0E.4.06000030

TXT.12.6.13C00000001A

TXT.18.2.4E75

TXT.1A.2.0000

RLD.02.4.´DIGIT´

RLD.14.4.´MAIN´

END.00

obs.: estes endereços estão em 32 bits (arquitetura do M68000)

endereços com notação em 1 byte


para futuro ajuste a referências (cont.)



TXT.00.6.103900000000

TXT.06.4.0C00000A

TXT.0A.2.6D02

TXT.0C.2.5E00

TXT.0E.4.06000030

TXT.12.6.13C00000001A

TXT.18.2.4E75

TXT.1A.2.0000

RLD.02.4.´DIGIT´

RLD.14.4.´MAIN´

END.00

MOVE.B DIGIT,D0

RLD permite ao passo-2 definir aqui o endereço externo de DIGIT





TXT.00.6.103900000000

TXT.06.4.0C00000A

TXT.0A.2.6D02

TXT.0C.2.5E00

TXT.0E.4.06000030

TXT.12.6.13C00000001A

TXT.18.2.4E75

TXT.1A.2.0000

RLD.02.4.´DIGIT´

RLD.14.4.´MAIN´

END.00

RLD permite ao passo-2 definir aqui o endereço de CHAR relativo a MAIN

MOVE.B D0,CHAR




Para PGM: ESD.´PGM´.´SD´.0000.0012

ESD.´DIGIT´.´LD´.10.2

TXT.00.6.30390000000E

TXT.06.6.33C000000010

TXT.0C.2.4E75

TXT.0E.2.0000

TXT.10.2.0000

RLD.02.4.´PGM´

RLD.08.4.´PGM´

END.




10.4 Carregador de ligação direta

(carregamento com ajuste a referências)‏

Carregadores de ligação direta são exemplo de um carregador básico que realiza ajustes de relocação e ligação a partir dos códigos objeto com o formato apresentado (tr. 515-519).

Tarefas do carregador de ligação direta:

• alocar espaço na memória principal que seja suficiente para carregar o programa completo

• resolver, definir endereços de cada símbolo exportado pelos módulos / segmentos

• transferir o código de cada módulo/segmento para a memória• ajustar, no código, posições de memória que fazem referências a

outras posições de memória



(carregamento com ajuste a referências)‏

Implementação em dois passos:

Passo-1: Resolução dos endereços• aloca espaço em memória

• define endereço inicial de memória para cada módulo/segmento• lê registros ESD

• cria Tabela de Símbolos Externos Globais (GEST) ‏

Passo-2: Transferência e ajustes• realiza a transferência dos registros TXT para a memória• altera as posições de memória indicadas nos registros RLD

• valores na GEST• inicia execução com endereço obtido em um registro END



Passo-1



Passo-2

ATENÇÃOconvenção

se POS ≠ { }

execuçãoSIZE:=campo tamanho



Exemplo – conforme transparências 515 a 519

Executando o algoritmo – Passo 1 (para segmento MAIN) ‏

passo1: PLA=end_inicial (definido como ‏($1000

registro é tipo ESD / SD, assim VALOR= $1000

SCOMP= $001C

SIMB= ´MAIN´

insere na GEST (MAIN , $1000)‏

pula outros registros até encontrar registro END

faz PLA= $1000 + $001C (lembrar $1C é o tamanho do seg. MAIN)‏



Exemplo – cont.

Continuando o passo1 agora para PGM:

passo1: PLA= $101C

registro é tipo ESD / SD, assim VALOR= $101C

SCOMP= $0012

SIMB= ´PGM´

insere na GEST (PGM , $101C) ‏

registro é tipo ESD / LD, assim POS= $10

VALOR= $101C + $10 = $102C

SIMB= ´DIGIT´

insere na GEST (DIGIT , $102C)‏

pula outros registros até encontrar registro END

faz PLA= $101C + $0012 (lembrar $12 é o tamanho do seg. PGM)‏



Exemplo – cont.

Ao final do passo1 temos a GEST gerada:

GEST:$102CDIGIT

$101CPGM

$1000MAIN


Inicia passo2 para MAIN e depois continua passo2 para PGM

passo2: PLA= $1000 ; EXE= $1000

registro é tipo ESD / SD, assim SCOMP= $1C

registro é tipo TXT: POS=0, SIZE= $6, CODE � cód. máquina

pos. memória PLA+POS recebe SIZE-bytes com CODE

repete processamento igual ao do último registro para todos

os regs. TXT

registro é tipo RLD: POS= $02, SIMB= ´DIGIT´, ENDR= $1002, SIZE=4

$1002:$1005 � ($1002:$1005) + $102C (end. final DIGIT)‏

registro é tipo RLD: POS= $14, SIMB= ´MAIN´, ENDR= $1014, SIZE=4

$1014:$1017 � ($1014:$1017) + $1000 (CHAR relativo PGM)‏

registro é tipo END: POS= $00, EXE= $1000, PLA= $101C


Exemplo – cont.


Continuando passo2 para PGM

passo2: PLA= $101C ; EXE= $1000

registro é tipo ESD / SD, assim SCOMP= $0012

registro é tipo ESD / LD, nada faz

registros seguintes são TXT: carrega código na memória

registros (dois) tipo RLD, com os quais as instruções de PGM são atualizadas com referência aos endereços finais de

VALUE e DIGIT

registro é tipo END: neste caso não há dados (EXE= $1000)‏

JUMP para $1000 e inicia processamento.


Exemplo – cont.


Ao final do passo2 teremos:

000000004E75102C000033C0102A$1020

0000303900004E75101A000013C00030$1010

06005E006D02000A0C00102C00001039$1000

0E0C0A0806040200Posição

(hexa)

Ao final do passo2 o carregador desvia (JUMP) para $1000.


Exemplo – cont.


000000004E75102C000033C0102A$1020

0000303900004E75101A000013C00030$1010

06005E006D02000A0C00102C00001039$1000

0E0C0A0806040200Posição

posições que sofreram ajuste (relocação ou ligação) de endereço (xxxx)

0000 000E + PGM ($101C) ‏

0000 0000 + DIGIT ($102C)‏

0000 0010 + PGM ($101C) ‏

0000 001A + MAIN ($1000) ‏

LR

RR


Exemplo – cont.



Desvantagens

• código do carregador torna-se mais complexo• como carregador compartilha memória com a execução da

aplicação, quanto mais simples for, melhor.

Estratégia alternativa

Separar as atividades de ligação daquelas de carregamento• só o carregador (mais simples) precisa compartilhar a

memória com a aplicação


10.5 Programas Ligadores

Então, um Programa Ligador, separado do carregador, será usado para criar um módulo de carga, realizando as seguintes tarefas:

•combinar os módulos objeto — com isto o esforço de ligação jáestá realizado;

•manter informação sobre ajustes necessários de relocação;•fazer o código relativo a um único símbolo: endereço inicial de

carregamento.

Exemplo:

Programa ld do Unix, invocado pelo compilador gcc aofinal da compilação para criar o código executável.


10.5 Programas Ligadores

segmento

segmento

ligador... ....módulo de carga

carregador

ESD.2E TXT.18.2.4E75 RLD.02.4

TXT.00.6.10390000002C TXT.1A.2.0000 RLD.14.4

TXT.06.4.0C00000A TXT.1C.6.30390000002A RLD.1E.4

TXT.0A.2.6D02 TXT.22.6.33C00000002C RLD.24.4

TXT.0C.2.5E00 TXT.28.2.4E75 END.00

TXT.0E.4.06000030 TXT.2A.2.0000

TXT.12.6.13C00000001A TXT.2C.2.0000

DIGIT

CHAR

VALUE

agora são relocados em relação a um end. inicial

memória

(conforme exemplo em 10.4)‏

(ver transparência 534)‏

Modelo com Programas Ligador e Carregador separados:


10.5 Programas LigadoresConforme exemplo estudado (10.4) – cont.

O programa ligador gera o módulo de carga como a seguir:

• o registro de início do segmento – ESD – indica o tamanho do código de máquina; no caso 2E ou 46 bytes

• o endereço inicial de carga é ipla = 0 (zero); todos os endereços passam a ser relativos a zero, antes da carga

• a saída é gravada em um arquivo para tratamento posterior pelo programa carregador

• a informação de relocação está ao final do módulo de carga (RLD); o endereço inicial de carregamento é a base para todos os ajustes a serem realizados pelo carregador


10.5 Programas LigadoresConforme exemplo estudado (10.4) – cont.

O programa carregador de posse do módulo de carga atua como a seguir:

• obtém o espaço necessário para a carga do registro ESD

• transfere o código, registros TXT

• realoca conforme os registros RLD

A transparência 536 mostra estes passos.


Carregador

Carregador de

módulo de carga


10.6 Bibliotecas

• Agrupam módulos de código objeto de uso comum – funções de E/S, matemáticas, etc.) - para fácil integração ao código da aplicação.

• São arquivos cujo conteúdo é um conjunto de outros arquivos (no caso, módulos objetos) com uma tabela para localizar e extrair facilmente esses arquivos.


10.6 Bibliotecas

Exemplo:

• Bibliotecas estáticas em Unix• criadas e mantidas com o aplicativo ar;

• os módulos necessários são extraídos e integrados ao código pelo aplicativo ld;

• bibliotecas a serem utilizadas são indicadas com a chave -lna linha de comando.


10.6 Bibliotecas

Tratamento com o utilitário ar : (cria, mantém e extrai módulos de bibliotecas estáticas no Linux).

• Módulo objeto arqmat.o é criado com > gcc -c arqmat.c

• Este módulo é incluído em libmy.a com > ar –r libmy.a arqmat.o

• libmay.a é a biblioteca estática do usuário;

• –r indica “replacement” caso o módulo já exista na biblioteca

• Outro módulo poderia ser incluído com > ar –r libmy.a convexp.o

• O comando “ar –t libmy.a” permite listar o conteúdo da biblioteca

no caso: arqmat.o e convexp.o

(estáticas) ‏


10.6 Bibliotecas

Exemplo de estrutura interna típica (campos):

Nome char name[16];Data de modificação char modtime[12];Usuário char uid[6];Grupo char gid[6];Permissões de acesso char mode[8];Dimensão char size[10];Marcador de fim char eol[2];

(estáticas) ‏


10.7 Carregamento e ligação dinâmicos

Os esquemas básicos apresentados até o momento são estáticos, ou seja:

• ligadores montam o módulo de carga completo antes do carregamento e execução do módulo;

• uma vez definido o endereço para o carregamento, esse não pode ser alterado até o final da execução.

Desvantagem

Em um ambiente que suporta multiprogramação (com execução simultânea de vários programas), vários módulos podem estar repetidos em diferentes aplicações.

• Redundância



Princípio: Adiar a definição do valor (endereço) do símbolo externo até o momento da execução do módulo.

Se um módulo já tiver sido carregado para a memória por uma outra aplicação, o mesmo endereço (ou seja, o mesmo módulo) pode ser utilizado pela aplicação corrente (lembrar

código reentrante).



(módulos objeto para ligação dinâmica) ‏

• código dos módulos deve ser reentrante• basicamente, sem variáveis globais ou estáticas

• códigos mantidos em bibliotecas dinâmicas• sistema Windows: DLL• sistema Linux: ELF (arquivos com extensão “so” – shared

objects)‏

• módulo de carga (o programa executável) é um módulo primário• referências aos módulos externos sem resolução (ver próximatransparência)



(estratégias para resolução dinâmica de referências) ‏

1. Referências são resolvidas quando o módulo primário é carregado (tempo de carregamento)‏;

ou,

2. Referências resolvidas quando símbolo éreferenciado (tempo de execução) .‏



1. Referências são resolvidas quando módulo primário é carregado (tempo de carregamento)‏.

• Quando o módulo de carga primário é carregado, todas as referências a módulos externos devem ser resolvidas;

• se módulo externo já está na memória, o mesmo endereço éutilizado;

• caso contrário, o módulo externo é carregado e seu endereço é definido;

• se algum módulo externo não for localizado, a execução éabortada.

É a solução utilizada no sistema Windows

DLL - Dynamic Link Library




• Execução inicia com o módulo de carga primário sem resolução das referências externas;

• apenas quando a referência externa for efetivamente necessária o sistema faz a resolução;

• se módulo já está na memória, o mesmo endereço é utilizado;• caso contrário, o módulo externo é carregado e seu endereço é

definido;• se referência não for utilizada, o módulo externo correspondente

nem precisa ser carregado;• eventualmente, a aplicação pode executar sem a instalação da

biblioteca dinâmica correspondente.

É a solução utilizada no sistema LinuxELF - Executable and Linkable Format

2. Referências resolvidas quando símbolo é referenciado (tempo de execução)‏

(estratégias para resolução dinâmica de referências)‏



Exemplo: carregamento dinâmico da função cos da biblioteca libm.so usando ELF

2. Referências resolvidas quando símbolo é referenciado (tempo de execução)‏

# include <dlfcn.h># include <stdio.h>

int main(int argc, char *argv[]) {void *handle;double (*cosine)(double);char *error;handle = dlopen("/lib/libm.so.5", RTLD_LAZY);cosine = dlsym(handle, "cos");printf("%f \n", (*cosine)(2.0));dlclose(handle);

}




Exemplo: carregamento dinâmico da função cos da biblioteca libm.so usando ELF (cont)‏

Lembrando as seguintes funções de manipulação de símbolos em ELF:

• dlopen abre o arquivo da biblioteca dinâmica• dlsym obtém endereço do símbolo especificado• dclose fecha a biblioteca dinâmica• dlerror emite mensagem de diagnóstico de erro



Cadeia de dependências: uma aplicação depende da biblioteca A, que depende da B, que depende. . .

Em sistemas com muitas aplicações instaladas (e desinstaladas), é possível que aplicações parem de funcionar por conta da ausência de uma biblioteca dinâmica removida inadvertidamenteou por incompatibilidade de versões.

. problema conhecido como DLL hell, e

. agravado por modificações locais não documentadas e pela ausência de um padrão de numeração de versões.

(problema da dependência de/entre bibliotecas)



Possíveis soluções

• manutenção de um controle de versões, com indicação de major version e minor version;

• atualizações de aplicações controladas por meio de um gerenciador de pacotes.

(problema da dependência de/entre bibliotecas)�


10.8 Exercícios

1. Qual a diferença entre o resultado gerado por um montador absoluto e um montador de ligação direta?

2. Qual a diferença entre ajuste de relocação e ajuste de ligação?3. Qual a diferença entre ligação dinâmica em tempo de carga e

em tempo de execução?4. Apresente situações nas quais seria interessante que a tabela de

símbolos gerada por um montador fosse incorporada ao módulo objeto gerado.

5. Como se comparam os tamanhos dos módulos objeto nos esquemas de carregamento estático e de carregamento dinâmico?

6. Um montador de ligação direta aplicado a dois arquivos em linguagem simbólica da família 68000 gerou os seguintes módulos objeto:


10.8 Exercícios (cont.) ‏

END.0000

RLD.000E.04.’MAIN’

RLD.0008.04.’CALC’

RLD.0002.04.’MAIN’

TXT.0014.04.00004E75

TXT.0012.02.4E75

END.TXT.000C.06.33C000000018

TXT.0004.02.4E75TXT.0006.06.4EB900000000

TXT.0002.02.9081TXT.0000.06.203900000014

TXT.0000.02.2200ESD.’RESULT’.’L’.0018.0002

ESD.’CALC’.’S’.0000.0006ESD.’MAIN’.’S’.0000.001A

Passados como argumentos nessa ordem (módulo 1, seguido de módulo 2) para um carregador de ligação direta; obteve-se o endereço inicial de carga (IPLA) $0200.


10.8 Exercícios (cont.) ‏

(a) Qual o conteúdo da Tabela de Símbolos Externos Globais (GEST) gerada pelo carregador?(b) O diagrama abaixo é um mapa de conteúdo da memória após o carregamento sem os ajustes de ligação e relocação. Indique neste mapa quais posições são ajustadas pelo carregador e qual o novo conteúdo destas posições.

4E759081220000004E7500004E750018021_

000033C0000000004EB9001400002039020_

ECA86420

10. software de sistema - carrega- dorese...

Documents