Ce n'linkers faire?

Je me suis toujours demandé. Je sais que les compilateurs de convertir le code que vous écrivez dans les fichiers binaires, mais ce n'linkers faire? Ils ont toujours été un mystère pour moi.

J'ai à peu près à comprendre ce que 'lier' est. C'est lorsque des références à des bibliothèques et des cadres sont ajoutés à la binaire. Je ne comprends rien au-delà. Pour moi, il "fonctionne". J'ai aussi comprendre les principes de base de la liaison dynamique, mais rien de trop profonde.

Quelqu'un pourrait-il expliquer les termes?

InformationsquelleAutor Kristina Brooks | 2010-07-23

c++dynamic-linking linker

130

De comprendre les linkers, il permet d'abord de comprendre ce qui se passe "sous le capot" lorsque vous convertissez un fichier source (comme un C ou C++ fichier) dans un fichier exécutable (un fichier exécutable est un fichier qui peuvent être exécutées sur votre machine, ou quelqu'un d'autre de la machine exécutant le même architecture de la machine).

Sous le capot, quand un programme est compilé, le compilateur convertit le fichier source dans l'objet du byte-code. Ce byte code (parfois appelé code de l'objet) est mnémoniques des instructions que seul votre architecture d'ordinateur comprend. Traditionnellement, ces fichiers ont une .OBJ extension.

Après le fichier objet est créé, l'éditeur de liens entre en jeu. Le plus souvent, un véritable programme qui ne fait rien d'utile aurez besoin de faire référence à d'autres fichiers. En C, par exemple, un programme simple pour imprimer votre nom à l'écran serait composé de:
```
printf("Hello Kristina!\n");
```
Lorsque le compilateur compiler votre programme dans un fichier obj, il met tout simplement une référence à la printf fonction. L'éditeur de liens résout cette référence. La plupart des langages de programmation disposent en série d'une bibliothèque de routines pour couvrir les trucs de base prévu à partir de cette langue. L'éditeur de liens de liens de votre fichier OBJ avec cette bibliothèque standard. L'éditeur de liens peut aussi le lien de votre fichier OBJ avec d'autres fichiers OBJ. Vous pouvez créer d'autres fichiers OBJ qui ont des fonctions qui peuvent être appelées par un autre fichier OBJ. Le linker fonctionne presque comme un traitement de texte est un copier-coller. Il "copies" de toutes les fonctions nécessaires pour que votre programme de références et crée un seul fichier exécutable. Parfois, d'autres bibliothèques qui sont copiées dépendent encore d'autres OBJ ou des fichiers de la bibliothèque. Parfois, un éditeur de liens doit être assez récursive pour faire son travail.

Noter que tous les systèmes d'exploitation de créer un seul fichier exécutable. Windows, par exemple, utilise les Dll de garder toutes ces fonctions dans un seul fichier. Cela réduit la taille de votre exécutable, mais rend votre exécutable dépend de ces Dll spécifiques. DOS habitude d'utiliser des choses que l'on appelle des Superpositions (.Les fichiers OVL). Cela a eu beaucoup de buts, mais l'un était de garder les fonctions les plus couramment utilisées ensemble dans 1 fichier (un autre but, il a servi, dans le cas où vous poseriez la question, était d'être capable de s'adapter à de grandes des programmes en mémoire. DOS a une limitation dans la mémoire et les superpositions pourrait être "déchargé" de la mémoire et d'autres superpositions pourrait être "chargé" sur le dessus de ce mémoire, d'où le nom de "couches"). Linux a des bibliothèques partagées, qui est essentiellement la même idée que Dll (noyau dur Linux les gars, je sais me dire il y a BEAUCOUP de GRANDES différences).

Espère que cela vous aide à comprendre!
- Grande réponse. En outre, la plupart des modernes linkers va supprimer code redondant comme modèle d'instanciations.
- Est-ce un bon endroit pour aller sur certains de ces différences?
- Bonjour, Supposons que mon fichier ne fait pas référence à un autre fichier. Supposons que j'ai simplement déclarer et initialiser deux variables. Sera-ce la source du fichier aussi aller à l'éditeur de liens?
- Oui, il va toujours par le biais d'un éditeur de liens. L'éditeur de liens ne pourrait pas le lien entre toutes les bibliothèques externes, mais le fait de lier la phase a encore pour arriver à produire un exécutable.
InformationsquelleAutor Icemanind
57

Adresse de réinstallation exemple minimal

Adresse de réinstallation est l'une des fonctions essentielles de la liaison.

Donc, nous allons avoir un regard sur la façon dont il fonctionne avec un exemple minimal.

0) Introduction

Résumé: la relocalisation des modifications de la .text section de l'objet des fichiers à traduire:
- objet adresse de fichier
- dans la dernière adresse de l'exécutable
Cela doit être fait par l'éditeur de liens, car le compilateur ne voit qu'un fichier d'entrée à un moment, mais il faut savoir à propos de tous les fichiers objet à la fois de décider comment:
- résoudre les symboles non définis comme déclaré fonctions non définies
- pas en conflit plusieurs .text et .data sections de plusieurs fichiers objets
- Requis: compréhension minimale de:
- x86-64 et IA-32 de l'assemblée
- structure globale d'un ELFE de fichier. J'ai fait un tutoriel pour que
Liaison n'a rien à voir avec le C ou le C++ en particulier: les compilateurs tout simplement de générer des fichiers de l'objet. L'éditeur de liens, puis prend comme entrée sans jamais savoir quelle langue compilés. Il pourrait aussi bien être Fortran.

Afin de réduire la croûte, nous allons étudier une MSNA x86-64 Linux ELF bonjour tout le monde:
```
section .data
    hello_world db "Hello world!", 10
section .text
    global _start
    _start:

        ; sys_write
        mov rax, 1
        mov rdi, 1
        mov rsi, hello_world
        mov rdx, 13
        syscall

        ; sys_exit
        mov rax, 60
        mov rdi, 0
        syscall
```
compilé et assemblé avec:
```
nasm -o hello_world.o hello_world.asm
ld -o hello_world.out hello_world.o
```
avec MSNA 2.10.09.

1) .texte de .o

Nous avons d'abord décompiler le .text section du fichier de l'objet:
```
objdump -d hello_world.o
```
qui donne:
```
0000000000000000 <_start>:
   0:   b8 01 00 00 00          mov    $0x1,%eax
   5:   bf 01 00 00 00          mov    $0x1,%edi
   a:   48 be 00 00 00 00 00    movabs $0x0,%rsi
  11:   00 00 00
  14:   ba 0d 00 00 00          mov    $0xd,%edx
  19:   0f 05                   syscall
  1b:   b8 3c 00 00 00          mov    $0x3c,%eax
  20:   bf 00 00 00 00          mov    $0x0,%edi
  25:   0f 05                   syscall
```
l'essentiel lignes sont:
```
   a:   48 be 00 00 00 00 00    movabs $0x0,%rsi
  11:   00 00 00
```
qui doit se déplacer à l'adresse du hello world chaîne dans le rsi registre, qui est passé à l'écriture de l'appel système.

Mais attendez! Comment le compilateur sait d'où "Hello world!" finira dans la mémoire lorsque le programme est chargé?

Bien, il ne peut pas, en particulier après que nous lien un tas de .o fichiers avec plusieurs .data sections.

Seulement l'éditeur de liens ne peut le faire que depuis seulement il va avoir toutes ces fichiers objets.

De sorte que le compilateur juste:
- met une valeur de l'espace réservé 0x0 sur la sortie compilée
- donne quelques informations supplémentaires à l'éditeur de liens de la manière de modifier le code compilé avec les bonnes adresses
Cette "information supplémentaire" est contenu dans la .rela.text section de l'objet fichier

2) .rela.texte

.rela.text est l'acronyme de "relocalisation de l' .section de texte".

Le mot de réinstallation est utilisé parce que l'éditeur de liens de déménager l'adresse de l'objet dans l'exécutable.

Nous pouvons démonter le .rela.text section avec:
```
readelf -r hello_world.o
```
qui contient;
```
Relocation section '.rela.text' at offset 0x340 contains 1 entries:
  Offset          Info           Type           Sym. Value    Sym. Name + Addend
00000000000c  000200000001 R_X86_64_64       0000000000000000 .data + 0
```
Le format de cette section est fixé documenté à: http://www.sco.com/developers/gabi/2003-12-17/ch4.reloc.html

Chaque entrée indique à l'éditeur de liens sur une adresse qui doit être déplacé, ici, nous avons seulement une pour la chaîne.

En simplifiant un peu, pour cette ligne en particulier, nous avons les informations suivantes:
- Offset = C: qu'est-ce que le premier octet de la .text que cette entrée changements.
  
  Si nous regardons en arrière à la décompilation d'un texte, il est exactement à l'intérieur de la critique movabs $0x0,%rsi, et ceux qui connaissent x86-64 codage d'instruction remarquerez que ce code de la 64 bits de l'adresse de la partie de l'instruction.
- Name = .data: l'adresse des points de la .data section
- Type = R_X86_64_64, qui précise ce qu'est exactement ce calcul doit être fait pour traduire l'adresse.
  
  Ce champ est effectivement processeur dépend, et donc documenté sur le Système AMD64 V ABI extension la section 4.4 "Relocalisation".
  
  Que le document dit que R_X86_64_64 n':
  - Field = word64: 8 octets, donc la 00 00 00 00 00 00 00 00 à l'adresse 0xC
  - Calculation = S + A
    
    S est valeur à l'adresse déplacée, donc 00 00 00 00 00 00 00 00
    
    A est le addend qui est 0 ici. C'est un domaine de la relocalisation de l'entrée.
    
    Donc S + A == 0 et nous aurons déménagé à la première adresse de la .data section.
3) .texte de .hors

Regardons maintenant la zone de texte de l'exécutable ld généré pour nous:
```
objdump -d hello_world.out
```
donne:
```
00000000004000b0 <_start>:
  4000b0:   b8 01 00 00 00          mov    $0x1,%eax
  4000b5:   bf 01 00 00 00          mov    $0x1,%edi
  4000ba:   48 be d8 00 60 00 00    movabs $0x6000d8,%rsi
  4000c1:   00 00 00
  4000c4:   ba 0d 00 00 00          mov    $0xd,%edx
  4000c9:   0f 05                   syscall
  4000cb:   b8 3c 00 00 00          mov    $0x3c,%eax
  4000d0:   bf 00 00 00 00          mov    $0x0,%edi
  4000d5:   0f 05                   syscall
```
Donc, la seule chose qui a changé à partir du fichier de l'objet sont les lignes critiques:
```
  4000ba:   48 be d8 00 60 00 00    movabs $0x6000d8,%rsi
  4000c1:   00 00 00
```
qui pointent désormais à l'adresse 0x6000d8 (d8 00 60 00 00 00 00 00 en little-endian) au lieu de 0x0.

Est-ce le bon endroit pour le hello_world chaîne?

De décider, nous devons vérifier le programme en-têtes, qui dites-Linux, où à la charge de chaque section.

Nous les démonter avec:
```
readelf -l hello_world.out
```
qui donne:
```
Program Headers:
  Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
  LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000
                 0x00000000000000d7 0x00000000000000d7  R E    200000
  LOAD           0x00000000000000d8 0x00000000006000d8 0x00000000006000d8
                 0x000000000000000d 0x000000000000000d  RW     200000

 Section to Segment mapping:
  Segment Sections...
   00     .text
   01     .data
```
Cela nous dit que le .data section, qui est le deuxième, commence à VirtAddr = 0x06000d8.

Et la seule chose sur la section de données est notre hello world chaîne.

Niveau Bonus
- PIE liens: Qu'est-ce que l'-fPIE option indépendante de la position des exécutables dans le gcc et ld?
InformationsquelleAutor Ciro Santilli 新疆改造中心996ICU六四事件
15

Dans les langues, comme "C", les modules de code sont traditionnellement compilé séparément dans des gouttes de code objet, qui est prêt à s'exécuter dans tous les domaines autres que celui de toutes les références que le module de l'extérieur de lui-même (c'est à dire à des bibliothèques ou à d'autres modules) n'ont pas encore été résolu (c'est à dire qu'ils sont vides, en attente de quelqu'un qui vient le long et en prenant toutes les connexions).

Ce que l'éditeur de liens n'est de regarder tous les modules ensemble, regarde ce que chaque module doit se connecter à l'extérieur de lui-même, et de regarder toutes les choses qu'il est de l'exportation. Il fixe alors que tout, et produit un exécutable final, qui peut ensuite être exécuté.

Où la liaison dynamique est également en cours, la sortie de l'éditeur de liens est encore pas capable de fonctionner - il y a encore quelques références à des bibliothèques externes pas encore résolu, et ils résolus par le système d'exploitation au moment du chargement de l'application (ou peut-être même plus tard au cours de l'exécution).
- Il est intéressant de noter que certains assembleurs ou les compilateurs peuvent en sortie un fichier exécutable directement si le compilateur "voit" tout ce qui est nécessaire (généralement dans un seul fichier source, plus tout ce qu'il #comprend). Quelques compilateurs, généralement pour les petits micros, ont que comme seul mode de fonctionnement.
- Oui, j'ai essayé de donner un moyen-de-la-route de réponse. Bien sûr, ainsi que votre cas, l'inverse est vrai aussi, que certains types de fichier de l'objet n'ont même pas le plein de génération de code fait, c'est fait par l'éditeur de liens (c'est comment MSVC ensemble du programme d'optimisation des œuvres).
- et du CCG Lien-Temps est de l'Optimisation, autant que je peux dire -, il transmet tous les le "code" que GIMPLE intermédiaire de la langue avec les métadonnées requises, fait que la disposition de l'éditeur de liens, et optimise en une seule fois à la fin. (En dépit de ce que documentation obsolète implique, seulement GIMPLE est maintenant diffusée par défaut, plutôt que de l'ancien "gras" mode avec les deux représentations de l'objet du code.)
InformationsquelleAutor Will Dean
10

Lorsque le compilateur génère un fichier de l'objet, il comprend des entrées pour les symboles sont définis dans ce fichier de l'objet, et des références à des symboles qui ne sont pas définies dans ce fichier de l'objet. L'éditeur de liens prend ceux et met donc (quand tout fonctionne à droite) toutes les références externes à partir de chaque fichier sont satisfaits par des symboles qui sont définies dans d'autres fichiers de l'objet.

Puis, il combine tous ces fichiers objets ensemble et attribue les adresses de chacun des symboles, et où l'un fichier objet a une référence externe à un autre objet fichier, il remplit dans l'adresse de chaque symbole partout où il est utilisé par un autre objet. Dans un cas typique, il va également construire un tableau de toutes les adresses absolues utilisées, de sorte que le chargeur peut/va "corriger" les adresses lorsque le fichier est chargé (c'est à dire, il va ajouter l'adresse de chargement de base pour chacune de ces adresses, de sorte qu'ils se réfèrent tous à la bonne adresse mémoire).

Tout à fait un peu de moderne linkers peut également effectuer certaines (dans quelques cas, une beaucoup) d'autres "trucs", comme l'optimisation du code dans les moyens qui ne sont possibles qu'une fois tous les modules sont visibles (par exemple, la suppression de fonctionnalités qui ont été inclus parce qu'il a été possible qu'un autre module pourrait les appeler, mais une fois que tous les modules sont mis ensemble, il est évident que rien ne les appelle).

InformationsquelleAutor Jerry Coffin

Vous devez vous connecter pour publier un commentaire.

Adresse de réinstallation exemple minimal

0) Introduction

1) .texte de .o

2) .rela.texte

3) .texte de .hors

Niveau Bonus