perkamon - en to fr translation catalogue (523 entries)

note: type: TH
en: 2007-05-18
fr: 18 mai 2007

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: dl_iterate_phdr - walk through list of shared objects
fr: dl_iterate_phdr - Parcourir une liste d'objets partagés

note: type: Plain text
en: B<#define _GNU_SOURCE>         /* See feature_test_macros(7) */
    B<#include E<lt>link.hE<gt>>
fr: B<#define _GNU_SOURCE>         /* Consultez feature_test_macros(7) */
    B<#include E<lt>link.hE<gt>>

note: type: Plain text
en: The B<dl_iterate_phdr>()  function allows an application to inquire at run time to find out which shared objects it has loaded.
fr: La fonction B<dl_iterate_phdr>() permet à une application de s'informer lors de son exécution, des objets partagés qu'elle a chargé.

note: type: Plain text
en: The B<dl_iterate_phdr>()  function walks through the list of an application's shared objects and calls the function I<callback> once for each object, until either all shared objects have been processed or I<callback> returns a nonzero value.
fr: La fonction B<dl_iterate_phdr>() parcourt la liste des objets partagés par une application et appelle la fonction I<callback> sur chaque objet jusqu'à ce que tous les objets partagés aient été traités ou que la fonction I<callback> ait renvoyé une valeur non nulle.

note: type: Plain text
en: Each call to I<callback> receives three arguments: I<info>, which is a pointer to a structure containing information about the shared object; I<size>, which is the size of the structure pointed to by I<info>; and I<data>, which is a copy of whatever value was passed by the calling program as the second argument (also named I<data>)  in the call to B<dl_iterate_phdr>().
fr: Chaque appel de I<callback> prend trois arguments\ : I<info> qui est un pointeur vers une structure contenant des informations sur les objets partagés\ ; I<size> qui est la taille de la structure pointée par I<info>\ ; et I<data> qui est une copie de toute valeur qui est passée par le programme appelant dans le second argument (également nommé I<data>) lors de l'appel de B<dl_iterate_phdr>().

note: type: Plain text
en: The I<info> argument is a structure of the following type:
fr: L'argument I<info> est une structure du type suivant\ :

note: type: Plain text
en: struct dl_phdr_info {
        ElfW(Addr)        dlpi_addr;  /* Base address of object */
        const char       *dlpi_name;  /* (Null-terminated) name of
                                         object */
        const ElfW(Phdr) *dlpi_phdr;  /* Pointer to array of
                                         ELF program headers
                                         for this object */
        ElfW(Half)        dlpi_phnum; /* # of items in I<dlpi_phdr> */
    };
fr: struct dl_phdr_info {
        ElfW(Addr)        dlpi_addr;  /* Adresse de base de l'objet */
        const char       *dlpi_name;  /* Nom de l'objet (terminée par
                                         un octet nul */
        const ElfW(Phdr) *dlpi_phdr;  /* Pointeur vers un tableau des
                                         en-têtes ELF du programme
                                         de cet objet */
        ElfW(Half)        dlpi_phnum; /* Nombre d'éléments dans 
                                         I<dlpi_phdr> */
    };

note: type: Plain text
en: (The I<ElfW>()  macro definition turns its argument into the name of an ELF data type suitable for the hardware architecture.  For example, on a 32-bit platform, ElfW(Addr) yields the data type name Elf32_Addr.  Further information on these types can be found in the I<E<lt>elf.hE<gt>> and I<E<lt>link.hE<gt>> header files.)
fr: (La macro I<ElfW>() convertit son argument en un nom de type de données ELF adapté à l'architecture matériel. Par exemple, sur un système 32-bits, ElfW(Addr) produit le type de données nommé Elf32_Addr. Des informations supplémentaires sur ces types peuvent être trouvées dans les fichiers d'en-tête I<E<lt>elf.hE<gt>> et I<E<lt>link.hE<gt>>).

note: type: Plain text
en: The I<dlpi_addr> field indicates the base address of the shared object (i.e., the difference between the virtual memory address of the shared object and the offset of that object in the file from which it was loaded).  The I<dlpi_name> field is a null-terminated string giving the pathname from which the shared object was loaded.
fr: Le champ I<dlpi_addr> indique l'adresse de base de l'objet partagé (la différence entre l'adresse en mémoire virtuelle de l'objet partagé et le décalage avec cet objet dans le fichier depuis lequel il a été chargé). Le champ I<dlpi_name> est une chaîne de caractères terminée par un caractère nul indiquant le chemin à partir duquel l'objet partagé a été chargé.

note: type: Plain text
en: To understand the meaning of the I<dlpi_phdr> and I<dlpi_phnum> fields, we need to be aware that an ELF shared object consists of a number of segments, each of which has a corresponding program header describing the segment.  The I<dlpi_phdr> field is a pointer to an array of the program headers for this shared object.  The I<dlpi_phnum> field indicates the size of this array.
fr: Pour comprendre le sens des champs I<dlpi_phdr> et I<dlpi_phnum>, il faut se rendre compte que les objets partagés ELF sont un nombre de segments, chacun d'eux possédant un en-tête décrivant le segment. Le champ I<dlpi_phdr> est un pointeur vers un tableau des en-têtes du programme de cet objet partagé. Le champ I<dlpi_phnum> est la taille de ce tableau.

note: type: Plain text
en: These program headers are structures of the following form:
fr: Ces en-têtes de programme sont structurés sous la forme suivantes\ :

note: type: Plain text
en: typedef struct {
        Elf32_Word  p_type;    /* Segment type */
        Elf32_Off   p_offset;  /* Segment file offset */
        Elf32_Addr  p_vaddr;   /* Segment virtual address */
        Elf32_Addr  p_paddr;   /* Segment physical address */
        Elf32_Word  p_filesz;  /* Segment size in file */
        Elf32_Word  p_memsz;   /* Segment size in memory */
        Elf32_Word  p_flags;   /* Segment flags */
        Elf32_Word  p_align;   /* Segment alignment */
    } Elf32_Phdr;
fr: typedef struct
      {
        Elf32_Word  p_type;    /* Type de segment */
        Elf32_Off   p_offset;  /* Décalage du fichier de segment (?) */
        Elf32_Addr  p_vaddr;   /* Adresse virtuelle du segment */
        Elf32_Addr  p_paddr;   /* Adresse physique du segment */
        Elf32_Word  p_filesz;  /* Taille du segment dans le fichier */
        Elf32_Word  p_memsz;   /* Taille du segment en mémoire */
        Elf32_Word  p_flags;   /* Drapeau du segment */
        Elf32_Word  p_align;   /* Alignement du segment */
    } Elf32_Phdr;

note: type: Plain text
en: Note that we can calculate the location of a particular program header, I<x>, in virtual memory using the formula:
fr: Notez que la position d'un en-tête de programme, I<x>, en mémoire virtuelle est calculée avec la formule suivante\ :

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: The B<dl_iterate_phdr>()  function returns whatever value was returned by the last call to I<callback>.
fr: La fonction B<dl_iterate_phdr>() renvoie quoi qu'il en soit la valeur renvoyée par le dernier appel à I<callback>.

note: type: Plain text
en: B<dl_iterate_phdr>()  has been supported in glibc since version 2.2.4.
fr: B<dl_iterate_phdr>() est géré par la glibc depuis la version 2.2.4.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: The B<dl_iterate_phdr>()  function is Linux-specific and should be avoided in portable applications.
fr: La fonction B<dl_iterate_phdr>() est spécifique à Linux et ne doit pas être utilisée pour des applications portables.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The following program displays a list of pathnames of the shared objects it has loaded.  For each shared object, the program lists the virtual addresses at which the object's ELF segments are loaded.
fr: Le programme suivant affiche la liste des chemins des objets partagés qu'il a chargé. Pour chaque objet partagé, le programme liste les adresses virtuelles auxquelles les segments ELF de l'objet sont chargés.

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: I<Executable and Linking Format Specification>, available at various locations online.
fr: « I<Executable and Linking Format Specification> » disponible en ligne à divers endroits.

note: type: Plain text
en: This page is part of release 3.65 of the Linux I<man-pages> project.  A description of the project, and information about reporting bugs, can be found at \%http://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 3.65 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%http://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2014-01-08
fr: 8 janvier 2014

note: type: Plain text
en: dladdr, dlclose, dlerror, dlopen, dlsym, dlvsym - programming interface to dynamic linking loader
fr: dladdr, dlclose, dlerror, dlopen, dlsym, dlvsym - Interface de programmation pour le chargeur de bibliothèques dynamiques

note: type: Plain text
en: Link with I<-ldl>.
fr: Effectuez l'édition des liens avec l'option I<-ldl>.

note: type: Plain text
en: The four functions B<dlopen>(), B<dlsym>(), B<dlclose>(), B<dlerror>()  implement the interface to the dynamic linking loader.
fr: Les quatre fonctions B<dlopen>(), B<dlsym>(), B<dlclose>(), B<dlerror>() implémentent l'interface pour le chargeur de bibliothèques dynamiques.

note: type: Plain text
en: The function B<dlerror>()  returns a human-readable string describing the most recent error that occurred from B<dlopen>(), B<dlsym>()  or B<dlclose>()  since the last call to B<dlerror>().  It returns NULL if no errors have occurred since initialization or since it was last called.
fr: La fonction B<dlerror>() renvoie une chaîne de caractères, compréhensible par l'homme, décrivant la dernière erreur survenue dans B<dlopen>(), B<dlsym>() ou B<dlclose>() depuis le dernier appel à B<dlerror>(). Elle renvoie NULL si aucune erreur n'est survenue depuis l'initialisation ou depuis son dernier appel.

note: type: Plain text
en: The function B<dlopen>()  loads the dynamic library file named by the null-terminated string I<filename> and returns an opaque "handle" for the dynamic library.  If I<filename> is NULL, then the returned handle is for the main program.  If I<filename> contains a slash ("/"), then it is interpreted as a (relative or absolute) pathname.  Otherwise, the dynamic linker searches for the library as follows (see B<ld.so>(8)  for further details):
fr: La fonction B<dlopen>() charge la bibliothèque dynamique dont le nom est fourni dans la chaîne I<filename> (terminée par un caractère nul) et renvoie un descripteur opaque (« handle ») représentant la bibliothèque dynamique. Si l'argument I<filename> est un pointeur NULL, le descripteur renvoyé correspond au programme principal. Si I<filename> contient une barre oblique («\ /\ »), il est interprété comme un chemin (relatif ou absolu). Autrement, le chargeur dynamique cherche la bibliothèque de la façon suivante (consultez B<ld.so>(8) pour plus de détails)\ :

note: type: Plain text
en: (ELF only) If the executable file for the calling program contains a DT_RPATH tag, and does not contain a DT_RUNPATH tag, then the directories listed in the DT_RPATH tag are searched.
fr: (ELF seulement) si le fichier exécutable pour le programme appelant contient la balise DT_RPATH mais pas la balise DT_RUNPATH, les répertoires listés dans la balise DT_RPATH seront parcourus.

note: type: Plain text
en: If, at the time that the program was started, the environment variable B<LD_LIBRARY_PATH> was defined to contain a colon-separated list of directories, then these are searched.  (As a security measure this variable is ignored for set-user-ID and set-group-ID programs.)
fr: Si à l'instant où le programme est démarré, la variable d'environnement B<LD_LIBRARY_PATH> est définie et contient une liste de répertoires (séparés par des deux-points «\ :\ »), ces répertoires seront parcourus. (Par mesure de sécurité, cette variable est ignorée dans le cas de programmes set-UID et set-GID).

note: type: Plain text
en: (ELF only) If the executable file for the calling program contains a DT_RUNPATH tag, then the directories listed in that tag are searched.
fr: (ELF seulement) si le fichier exécutable pour le programme appelant contient la balise DT_RUNPATH, les répertoires listés dans cette balise seront parcourus.

note: type: Plain text
en: The cache file I</etc/ld.so.cache> (maintained by B<ldconfig>(8))  is checked to see whether it contains an entry for I<filename>.
fr: Le fichier de cache I</etc/ld.so.cache> (maintenu par B<ldconfig>(8)) est vérifié pour voir s'il contient une entrée correspondant à I<filename>.

note: type: Plain text
en: The directories I</lib> and I</usr/lib> are searched (in that order).
fr: Les répertoires I</lib> et I</usr/lib> sont parcourus (dans cet ordre).

note: type: Plain text
en: If the library has dependencies on other shared libraries, then these are also automatically loaded by the dynamic linker using the same rules.  (This process may occur recursively, if those libraries in turn have dependencies, and so on.)
fr: Si la bibliothèque a des dépendances sur d'autres bibliothèques partagées, celles-ci seront automatiquement chargées par le chargeur dynamique, en utilisant les mêmes règles. (Le processus peut être récursif si ces bibliothèques ont, à leur tour, des dépendances, et ainsi de suite.)

note: type: Plain text
en: One of the following two values must be included in I<flag>:
fr: L'une des deux valeurs suivantes doit être incluse dans I<flag>\ :

note: type: Plain text
en: Perform lazy binding.  Only resolve symbols as the code that references them is executed.  If the symbol is never referenced, then it is never resolved.  (Lazy binding is performed only for function references; references to variables are always immediately bound when the library is loaded.)
fr: Effectuer des liaisons paresseuses. Résoudre seulement les symboles dont le code qui les référence est exécuté. Si le symbole n'est jamais référencé, alors il n'est jamais résolu. (Les bindings paresseux ne sont seulement effectués que pour les références de fonctions\ ; les références de variables sont toujours immédiatement liées quand la bibliothèque est chargée).

note: type: Plain text
en: If this value is specified, or the environment variable B<LD_BIND_NOW> is set to a nonempty string, all undefined symbols in the library are resolved before B<dlopen>()  returns.  If this cannot be done, an error is returned.
fr: Si cette valeur est spécifiée, ou que la variable d'environnement B<LD_BIND_NOW> est définie avec une chaîne non vide, tous les symboles non définis de la bibliothèque sont résolus avant le retour de B<dlopen>(). Si cela ne peut pas être fait, une erreur est renvoyée.

note: type: Plain text
en: Zero or more of the following values may also be ORed in I<flag>:
fr: Zéro ou plusieurs des valeurs suivantes peuvent être spécifiées avec un OU binaire dans I<flag>\ :

note: type: Plain text
en: The symbols defined by this library will be made available for symbol resolution of subsequently loaded libraries.
fr: Les symboles définis par cette bibliothèque seront disponibles pour la résolution des symboles des futurs chargements de bibliothèques.

note: type: Plain text
en: This is the converse of B<RTLD_GLOBAL>, and the default if neither flag is specified.  Symbols defined in this library are not made available to resolve references in subsequently loaded libraries.
fr: C'est la réciproque de B<RTLD_GLOBAL>, et le comportement par défaut si aucun drapeau n'est spécifié. Les symboles définis dans cette bibliothèque ne sont pas disponibles pour résoudre les références des chargements de bibliothèques futurs.

note: type: TP
en: B<RTLD_NODELETE> (since glibc 2.2)
fr: B<RTLD_NODELETE> (depuis la glibc\ 2.2)

note: (But it is present on Solaris.) type: Plain text
en: Do not unload the library during B<dlclose>().  Consequently, the library's static variables are not reinitialized if the library is reloaded with B<dlopen>()  at a later time.  This flag is not specified in POSIX.1-2001.
fr: Ne pas décharger la bibliothèque lors de B<dlclose>(). En conséquence, les variables statiques de la bibliothèque ne sont pas réinitialisées si la bibliothèque est chargée ultérieurement avec B<dlopen>() . Ce drapeau n'est pas spécifié dans POSIX.1-2001.

note: type: TP
en: B<RTLD_NOLOAD> (since glibc 2.2)
fr: B<RTLD_NOLOAD> (depuis la glibc\ 2.2)

note: (But it is present on Solaris.) type: Plain text
en: Don't load the library.  This can be used to test if the library is already resident (B<dlopen>()  returns NULL if it is not, or the library's handle if it is resident).  This flag can also be used to promote the flags on a library that is already loaded.  For example, a library that was previously loaded with B<RTLD_LOCAL> can be reopened with B<RTLD_NOLOAD\ |\ RTLD_GLOBAL>.  This flag is not specified in POSIX.1-2001.
fr: Ne pas charger la bibliothèque. Ceci peut être utilisé pour tester si la bibliothèque n'est pas déjà chargée (B<dlopen>() renvoie NULL si elle n'est pas chargée, ou le descripteur de la bibliothèque si elle déjà chargée). Ce drapeau peut aussi être utilisé pour promouvoir les drapeaux d'une bibliothèque déjà chargée. Par exemple, une bibliothèque qui a été chargée avec B<RTLD_LOCAL> peut être de nouveau ouverte avec B<RTLD_NOLOAD\ |\ RTLD_GLOBAL>. Ce drapeau n'est pas spécifié dans POSIX.1-2001.

note: type: TP
en: B<RTLD_DEEPBIND> (since glibc 2.3.4)
fr: B<RTLD_DEEPBIND> (depuis la glibc\ 2.3.4)

note: Inimitably described by UD in http://sources.redhat.com/ml/libc-hacker/2004-09/msg00083.html. type: Plain text
en: Place the lookup scope of the symbols in this library ahead of the global scope.  This means that a self-contained library will use its own symbols in preference to global symbols with the same name contained in libraries that have already been loaded.  This flag is not specified in POSIX.1-2001.
fr: Placer l'espace de recherche des symboles de cette bibliothèque avant l'espace global. Cela signifie qu'une bibliothèque autonome utilisera ses propres symboles de préférence aux symboles globaux de même noms contenus dans les bibliothèques déjà chargées. Ce drapeau n'est pas spécifié dans POSIX.1-2001.

note: type: Plain text
en: If I<filename> is NULL, then the returned handle is for the main program.  When given to B<dlsym>(), this handle causes a search for a symbol in the main program, followed by all shared libraries loaded at program startup, and then all shared libraries loaded by B<dlopen>()  with the flag B<RTLD_GLOBAL>.
fr: Si l'argument I<filename> est un pointeur NULL, le descripteur renvoyé correspond au programme principal. Lorsqu'il est passé à B<dlsym>(), ce descripteur provoque la recherche d'un symbole dans le programme principal, puis dans toutes les bibliothèques partagées chargées au démarrage du programme, puis dans toutes les bibliothèques partagées chargées par B<dlopen>() avec l'attribut B<RTLD_GLOBAL>.

note: type: Plain text
en: External references in the library are resolved using the libraries in that library's dependency list and any other libraries previously opened with the B<RTLD_GLOBAL> flag.  If the executable was linked with the flag "-rdynamic" (or, synonymously, "--export-dynamic"), then the global symbols in the executable will also be used to resolve references in a dynamically loaded library.
fr: Les références externes de la bibliothèque sont résolues en utilisant les bibliothèques mentionnées dans sa liste de dépendances, et toutes les autres bibliothèques éventuellement ouvertes auparavant avec le drapeau B<RTLD_GLOBAL>. Si l'édition des liens de l'exécutable a été faite avec l'option «\ -rdynamic\ » (ou, de manière synonyme, avec «\ --export-dynamic\ »), alors les symboles globaux du programme seront également utilisés pour résoudre les références d'une bibliothèque chargée dynamiquement.

note: type: Plain text
en: If the same library is loaded again with B<dlopen>(), the same file handle is returned.  The dl library maintains reference counts for library handles, so a dynamic library is not deallocated until B<dlclose>()  has been called on it as many times as B<dlopen>()  has succeeded on it.  The B<_init>()  routine, if present, is called only once.  But a subsequent call with B<RTLD_NOW> may force symbol resolution for a library earlier loaded with B<RTLD_LAZY>.
fr: Si la même bibliothèque est chargée une nouvelle fois avec B<dlopen>(), le même descripteur sera renvoyé. Un compte du nombre de chargements est toutefois conservé afin d'éviter de la décharger avant que la fonction B<dlclose>() n'ait été appelée autant de fois que B<dlopen>() a réussi. La routine B<_init>, si elle existe, est appelée une seule fois. Mais un appel postérieur avec B<RTLD_NOW> peut forcer la résolution des symboles pour une bibliothèque précédemment chargée avec B<RTLD_LAZY>.

note: type: Plain text
en: If B<dlopen>()  fails for any reason, it returns NULL.
fr: Si B<dlopen>() échoue pour une raison quelconque, elle renvoie NULL.

note: type: Plain text
en: The function B<dlsym>()  takes a "handle" of a dynamic library returned by B<dlopen>()  and the null-terminated symbol name, returning the address where that symbol is loaded into memory.  If the symbol is not found, in the specified library or any of the libraries that were automatically loaded by B<dlopen>()  when that library was loaded, B<dlsym>()  returns NULL.  (The search performed by B<dlsym>()  is breadth first through the dependency tree of these libraries.)  Since the value of the symbol could actually be NULL (so that a NULL return from B<dlsym>()  need not indicate an error), the correct way to test for an error is to call B<dlerror>()  to clear any old error conditions, then call B<dlsym>(), and then call B<dlerror>()  again, saving its return value into a variable, and check whether this saved value is not NULL.
fr: La fonction B<dlsym>() prend comme arguments, un «\ descripteur\ » de bibliothèque dynamique renvoyé par B<dlopen>() et un nom de symbole terminé par un caractère nul, et renvoie l'adresse où ce symbole a été chargé en mémoire. Si le symbole n'est pas trouvé, soit dans la bibliothèque spécifiée, soit dans n'importe quelle bibliothèque chargée automatiquement par B<dlopen>() lorsque cette bibliothèque a été chargée, B<dlsym>() renvoie NULL. (La recherche effectuée par B<dlsym>() est d'abord en largeur à travers l'arbre des dépendances de ces bibliothèques). Le symbole pouvant légitimement avoir la valeur NULL (la valeur NULL renvoyée par B<dlsym>() n'indique pas nécessairement une erreur), la bonne manière de vérifier si une erreur s'est produite est d'appeler B<dlerror>() pour effacer toute ancienne condition d'erreur, puis d'appeler B<dlsym>() et appeler une nouvelle fois B<dlerror>() en sauvegardant sa valeur de retour dans une variable et vérifier si la valeur sauvegardée n'est pas NULL.

note: type: Plain text
en: There are two special pseudo-handles, B<RTLD_DEFAULT> and B<RTLD_NEXT>.  The former will find the first occurrence of the desired symbol using the default library search order.  The latter will find the next occurrence of a function in the search order after the current library.  This allows one to provide a wrapper around a function in another shared library.
fr: Il y a deux pseudodescripteurs spéciaux\ : B<RTLD_DEFAULT> et B<RTLD_NEXT>. Le premier recherche la première occurrence du symbole désiré en utilisant l'ordre de recherche des bibliothèques par défaut. Le second recherche l'occurrence suivante d'une fonction à partir de la bibliothèque en cours. Ceci permet de fournir une enveloppe pour une fonction se trouvant dans une autre bibliothèque partagée.

note: type: Plain text
en: The function B<dlclose>()  decrements the reference count on the dynamic library handle I<handle>.  If the reference count drops to zero and no other loaded libraries use symbols in it, then the dynamic library is unloaded.
fr: La fonction B<dlclose>() décrémente le nombre de références d'une bibliothèque dynamique dont le descripteur est I<handle>. Si ce nombre atteint zéro et si aucune autre bibliothèque n'emploie des symboles exportés par celle-ci, elle est déchargée.

note: type: Plain text
en: The function B<dlclose>()  returns 0 on success, and nonzero on error.
fr: La fonction B<dlclose>() renvoie 0 si elle réussit, et une valeur non nulle en cas d'erreur.

note: type: SS
en: The obsolete symbols _init() and _fini()
fr: Les symboles obsolètes _init() et _fini()

note: type: Plain text
en: The linker recognizes special symbols B<_init> and B<_fini>.  If a dynamic library exports a routine named B<_init>(), then that code is executed after the loading, before B<dlopen>()  returns.  If the dynamic library exports a routine named B<_fini>(), then that routine is called just before the library is unloaded.  In case you need to avoid linking against the system startup files, this can be done by using the B<gcc>(1)  I<-nostartfiles> command-line option.
fr: L'éditeur de liens reconnaît les symboles spéciaux B<_init> et B<_fini>. Si une bibliothèque dynamique exporte une routine nommée B<_init>(), alors son code est exécuté après le chargement, avant le retour de B<dlopen>(). Si la bibliothèque exporte une routine nommée B<_fini>, elle est appelée juste avant le déchargement. Au cas où vous voudriez éviter de lier l'exécutable avec les fichiers de démarrage du système, vous pouvez spécifier le paramètre I<-nostartfiles> à la ligne de commande de B<gcc>(1).

note: void _init(void) __attribute__((constructor)); void _fini(void) __attribute__((destructor)); type: Plain text
en: Using these routines, or the gcc B<-nostartfiles> or B<-nostdlib> options, is not recommended.  Their use may result in undesired behavior, since the constructor/destructor routines will not be executed (unless special measures are taken).
fr: L'utilisation de ces routines ou des options gcc B<-nostartfiles> ou B<-nostdlib> n'est pas recommandée. Il peut en résulter un comportement non désiré tant que les routines constructeur/destructeur ne sont pas exécutées (à moins que des mesures spéciales ne soient prises).

note: type: Plain text
en: Instead, libraries should export routines using the B<__attribute__((constructor))> and B<__attribute__((destructor))> function attributes.  See the gcc info pages for information on these.  Constructor routines are executed before B<dlopen>()  returns, and destructor routines are executed before B<dlclose>()  returns.
fr: À la place, les bibliothèques devraient exporter les routines en utilisant les fonctions attribut B<__attribute__((constructor))> et B<__attribute__((destructor))>. Consultez la documentation de gcc au format Info pour plus d'information sur celles-ci. Les routines constructeur sont exécutées avant que B<dlopen> revienne et les routines destructeur sont exécutées avant que B<dlclose> revienne.

note: type: SS
en: Glibc extensions: dladdr() and dlvsym()
fr: Extensions de la glibc\ :dladdr() et dlvsym()

note: type: Plain text
en: Glibc adds two functions not described by POSIX, with prototypes
fr: La glibc a ajouté deux fonctions, qui ne sont pas décrites par POSIX, dont les prototypes sont\ :

note: type: Plain text
en: B<#define _GNU_SOURCE>         /* See feature_test_macros(7) */
    B<#include E<lt>dlfcn.hE<gt>>
fr: B<#define _GNU_SOURCE>         /* Consultez feature_test_macros(7) */
    B<#include E<lt>dlfcn.hE<gt>>

note: type: Plain text
en: The function B<dladdr>()  takes a function pointer and tries to resolve name and file where it is located.  Information is stored in the I<Dl_info> structure:
fr: La fonction B<dladdr>() prend un pointeur vers une fonction et essaie de résoudre le nom et le fichier où il se trouve. L'information est stockée dans une structure I<Dl_info>\ :

note: type: Plain text
en: typedef struct {
        const char *dli_fname;  /* Pathname of shared object that
                                   contains address */
        void       *dli_fbase;  /* Address at which shared object
                                   is loaded */
        const char *dli_sname;  /* Name of symbol whose definition
                                   overlaps I<addr> */
        void       *dli_saddr;  /* Exact address of symbol named
                                   in I<dli_sname> */
    } Dl_info;
fr: typedef struct {
        const char *dli_fname; /* Chemin du fichier de l'objet partagé
                                  contenant l'adresse */
        void       *dli_fbase; /* Adresse à laquelle l'objet partagé
                                  est chargé */
        const char *dli_sname; /* Nom du symbole dont la définition
                                  chevauche I<addr> */
        void       *dli_saddr; /* Adresse exacte du symbole dont
                                  le nom est I<dli_sname> */
    } Dl_info;

note: type: Plain text
en: If no symbol matching I<addr> could be found, then I<dli_sname> and I<dli_saddr> are set to NULL.
fr: Si aucun symbole correspondant à l'adresse I<addr> ne peut être trouvé, I<dli_sname> et I<dli_saddr> sont définis à NULL.

note: type: Plain text
en: B<dladdr>()  returns 0 on error, and nonzero on success.
fr: B<dladdr>() renvoie 0 en cas d'erreur et une valeur non nulle en cas de succès.

note: type: Plain text
en: The function B<dlvsym>(), provided by glibc since version 2.1, does the same as B<dlsym>()  but takes a version string as an additional argument.
fr: La fonction B<dlvsym>(), fournie par la glibc depuis la version 2.1, effectue la même chose que B<dlsym>() mais prend une version sous forme de chaîne comme argument supplémentaire.

note: type: Plain text
en: POSIX.1-2001 describes B<dlclose>(), B<dlerror>(), B<dlopen>(), and B<dlsym>().
fr: POSIX.1-2001 décrit B<dlclose>(), B<dlerror>(), B<dlopen>() et B<dlsym>().

note: .LP The string returned by .BR dlerror () should not be modified. Some systems give the prototype as .sp .in +5 .B "const char *dlerror(void);" .in type: Plain text
en: The symbols B<RTLD_DEFAULT> and B<RTLD_NEXT> are defined by I<E<lt>dlfcn.hE<gt>> only when B<_GNU_SOURCE> was defined before including it.
fr: Les symboles B<RTLD_DEFAULT> et B<RTLD_NEXT> sont définis dans I<E<lt>dlfcn.hE<gt>> seulement si B<_GNU_SOURCE> a été définie avant l'inclusion.

note: type: Plain text
en: Since glibc 2.2.3, B<atexit>(3)  can be used to register an exit handler that is automatically called when a library is unloaded.
fr: Depuis la glibc\ 2.2.3, B<atexit>(3) peut être utilisée pour enregistrer un gestionnaire de sortie qui sera automatiquement appelé quand une bibliothèque sera déchargée.

note: type: SS
en: History
fr: Historique

note: type: Plain text
en: The dlopen interface standard comes from SunOS.  That system also has B<dladdr>(), but not B<dlvsym>().
fr: L'interface standard dlopen provient de SunOS. Ce système possède également B<dladdr>() mais pas B<dlvsym>().

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: Sometimes, the function pointers you pass to B<dladdr>()  may surprise you.  On some architectures (notably i386 and x86_64), I<dli_fname> and I<dli_fbase> may end up pointing back at the object from which you called B<dladdr>(), even if the function used as an argument should come from a dynamically linked library.
fr: Quelquefois, les pointeurs de fonctions passés à B<dladdr>() peuvent vous surprendre. Sur certaines architectures (notablement i386 et x86_64), I<dli_fname> et I<dli_fbase> peuvent pointés sur l'objet depuis lequel vous appelez B<dladdr>(), même si la fonction utilisée en paramètre semble provenir d'une bibliothèque liée dynamiquement.

note: type: Plain text
en: The problem is that the function pointer will still be resolved at compile time, but merely point to the I<plt> (Procedure Linkage Table)  section of the original object (which dispatches the call after asking the dynamic linker to resolve the symbol).  To work around this, you can try to compile the code to be position-independent: then, the compiler cannot prepare the pointer at compile time anymore and today's B<gcc>(1)  will generate code that just loads the final symbol address from the I<got> (Global Offset Table) at run time before passing it to B<dladdr>().
fr: Le problème est que le pointeur de fonction ne sera résolu que lors de la compilation, mais pointe simplement vers la section de l'objet original I<plt> (table de procédure d'édition des liens), qui redirige l'appel après avoir demandé à l'éditeur de liens dynamique de résoudre le symbole). Un contournement consiste à compiler le code pour qu'il soit indépendant de son adressage : dans ce cas le compilateur ne peut pas préparer le pointeur à la compilation, et de nos jours, B<gcc>(1) générera du code qui chargera juste l'adresse finale du symbole depuis la table I<GOT> (table d'offset globale) lors de l'exécution, avant de la passer à B<dladdr>().

note: type: Plain text
en: Load the math library, and print the cosine of 2.0:
fr: Charger la bibliothèque mathématique et afficher le cosinus de 2,0\ :

note: type: Plain text
en:     /* According to the ISO C standard, casting between function
           pointers and 'void *', as done above, produces undefined results.
           POSIX.1-2003 and POSIX.1-2008 accepted this state of affairs and
           proposed the following workaround:
fr:     /* D'après le standard ISO C, la conversion de type entre un pointeur
           de fonction et « void * », comme effectuée ci-dessus, produit des
           résultats indéfinis.
           POSIX.1-2003 et POSIX.1-2008 ont admis cet état de fait et proposé
           le contournement ci-dessous :

note: type: Plain text
en:        This (clumsy) cast conforms with the ISO C standard and will
           avoid any compiler warnings.
fr:        Cette conversion (lourde) de type est conforme au standard
           ISO C and évitera tout avertissement du compilateur.

note: http://pubs.opengroup.org/onlinepubs/009695399/functions/dlsym.html#tag_03_112_08 http://pubs.opengroup.org/onlinepubs/9699919799/functions/dlsym.html#tag_16_96_07 http://austingroupbugs.net/view.php?id=74 type: Plain text
en:        The 2013 Technical Corrigendum to POSIX.1-2008 (a.k.a.
           POSIX.1-2013) improved matters by requiring that conforming
           implementations support casting 'void *' to a function pointer.
           Nevertheless, some compilers (e.g., gcc with the '-pedantic'
           option) may complain about the cast used in this program. */
fr:        La révision technique 2013 de POSIX.1-2008 (aussi appelée
           POSIX.1-2013) a amélioré la situation en exigeant que les
           implémentations prennent en charge la conversion du type 
           « void * » vers un pointeur de fonction.'
           Cependant, certains compilateurs (par exemple gcc avec
           l'option « -pedantic ) peuvent se plaindre de la conversion
           effectuée dans ce programme. */

note: type: Plain text
en: If this program were in a file named "foo.c", you would build the program with the following command:
fr: Supposons que le programme s'appelle «\ foo.c\ », on doit le compiler ainsi\ :

note: type: Plain text
en: Libraries exporting B<_init>()  and B<_fini>()  will want to be compiled as follows, using I<bar.c> as the example name:
fr: Une bibliothèque (I<bar.c> dans l'exemple suivant) qui exporte B<_init()> et B<_fini()> sera compilée comme suit\ :

note: type: Plain text
en: ld.so info pages, gcc info pages, ld info pages
fr: les pages Info de ld.so, gcc, ld

note: type: TH
en: 2013-04-17
fr: 17 avril 2013

note: type: Plain text
en: elf - format of Executable and Linking Format (ELF) files
fr: elf - Format des fichiers exécutables ELF (« Executable and Linking Format »)

note: type: Plain text
en: The header file I<E<lt>elf.hE<gt>> defines the format of ELF executable binary files.  Amongst these files are normal executable files, relocatable object files, core files and shared libraries.
fr: Le fichier d'en-tête I<E<lt>elf.hE<gt>> définit le format des fichiers binaires exécutables ELF. Ces fichiers peuvent être soit des fichiers exécutables normaux, des fichiers objets repositionnables, des fichiers core ou des bibliothèques partagées.

note: type: Plain text
en: An executable file using the ELF file format consists of an ELF header, followed by a program header table or a section header table, or both.  The ELF header is always at offset zero of the file.  The program header table and the section header table's offset in the file are defined in the ELF header.  The two tables describe the rest of the particularities of the file.
fr: Un fichier exécutable utilisant le format de fichier ELF est constitué d'un en-tête ELF, suivi d'une table d'en-tête de programme ou d'une table des en-têtes de sections, ou des deux. L'en-tête ELF est toujours situé à un déplacement de zéro par rapport au début du fichier. Les déplacements dans le fichier des tables d'en-tête de programme et des en-têtes de sections sont définis dans l'en-tête ELF. Ces deux tables décrivent le reste des particularités du fichier.

note: Applications which wish to process ELF binary files for their native architecture only should include .I <elf_abi.h> in their source code. These applications should need to refer to all the types and structures by their generic names "Elf_xxx" and to the macros by ELF_xxx". Applications written this
en: This header file describes the above mentioned headers as C structures and also includes structures for dynamic sections, relocation sections and symbol tables.
fr: Ce fichier d'en-tête décrit, sous la forme de structures C, les en-têtes mentionnés précédemment et inclut également des structures pour les sections dynamiques, les sections de repositionnement et les tables de symboles.

note: type: Plain text
en: The following types are used for N-bit architectures (N=32,64, I<ElfN> stands for I<Elf32> or I<Elf64>, I<uintN_t> stands for I<uint32_t> or I<uint64_t>):
fr: Les types suivants sont utilisés pour les architectures N-bit (avec I<N=32,64> ; I<ElfN> signifie I<Elf32> ou I<Elf64> ; I<uintN_t> signifie I<uint32_t> ou I<uint64_t>) :

note: Elf32_Size  Unsigned object size type: Plain text
en: ElfN_Addr       Unsigned program address, uintN_t
    ElfN_Off        Unsigned file offset, uintN_t
    ElfN_Section    Unsigned section index, uint16_t
    ElfN_Versym     Unsigned version symbol information, uint16_t
    Elf_Byte        unsigned char
    ElfN_Half       uint16_t
    ElfN_Sword      int32_t
    ElfN_Word       uint32_t
    ElfN_Sxword     int64_t
    ElfN_Xword      uint64_t
fr: ElfN_Addr       adresse (non signée) du programme, uintN_t
    ElfN_Off        déplacement (non signé) dans le fichier, uintN_t
    ElfN_Section    indice (non signé) de section, uint16_t
    ElfN_Versym     informations (non signées) sur les versions
                    des symboles, uint16_t
    Elf_Byte        caractère (char) non signé
    ElfN_Half       uint16_t
    ElfN_Sword      int32_t
    ElfN_Word       uint32_t
    ElfN_Sxword     int64_t
    ElfN_Xword      uint64_t

note: type: Plain text
en: (Note: The *BSD terminology is a bit different.  There I<Elf64_Half> is twice as large as I<Elf32_Half>, and I<Elf64Quarter> is used for I<uint16_t>.  In order to avoid confusion these types are replaced by explicit ones in the below.)
fr: (Note : la terminologie *BSD est quelque peu différente. I<Elf64_Half> est deux fois plus grand que I<Elf32_Half> et I<Elf64Quarter> est utilisé pour I<uint16_t>. Afin d'éviter toute confusion, ces types seront remplacés par des types plus explicites dans la suite de ce document).

note: type: Plain text
en: All data structures that the file format defines follow the "natural" size and alignment guidelines for the relevant class.  If necessary, data structures contain explicit padding to ensure 4-byte alignment for 4-byte objects, to force structure sizes to a multiple of 4, and so on.
fr: Toutes les structures de données définies par le format de fichier suivent la taille « naturelle » et les principes d'alignement de la classe correspondante. Si nécessaire, les structures de données contiennent un remplissage explicite pour assurer l'alignement sur 4 octets des objets de 4 octets, et pour forcer les tailles des structures à être des multiples de 4, etc.

note: type: Plain text
en: The ELF header is described by the type I<Elf32_Ehdr> or I<Elf64_Ehdr>:
fr: L'en-tête ELF est décrit par le type I<Elf32_Ehdr> ou par le type I<Elf64_Ehdr> :

note: .Bl -tag -width "e_phentsize" type: Plain text
en: The fields have the following meanings:
fr: Les champs ont les significations suivantes :

note: type: Plain text
en: This array of bytes specifies to interpret the file, independent of the processor or the file's remaining contents.  Within this array everything is named by macros, which start with the prefix B<EI_> and may contain values which start with the prefix B<ELF>.  The following macros are defined:
fr: Ce tableau d'octets indique comment interpréter le fichier, indépendamment du processeur ou du reste du contenu du fichier. Dans ce tableau, chacun des éléments s'appelle une macro qui commence par le préfixe B<EI_> et peut contenir des valeurs commençant par le préfixe B<ELF>. Les macros suivantes sont définies :

note: type: Plain text
en: The first byte of the magic number.  It must be filled with B<ELFMAG0>.  (0: 0x7f)
fr: Premier octet du nombre magique. Il doit être rempli par B<ELFMAG0> (0: 0x7f).

note: type: Plain text
en: The second byte of the magic number.  It must be filled with B<ELFMAG1>.  (1: \(aqE\(aq)
fr: Deuxième octet du nombre magique. Il doit être rempli par B<ELFMAG1> (1: « E »).

note: type: Plain text
en: The third byte of the magic number.  It must be filled with B<ELFMAG2>.  (2: \(aqL\(aq)
fr: Troisième octet du nombre magique. Il doit être rempli par B<ELFMAG2> (2: « L »).

note: type: Plain text
en: The fourth byte of the magic number.  It must be filled with B<ELFMAG3>.  (3: \(aqF\(aq)
fr: Quatrième octet du nombre magique. Il doit être rempli par B<ELFMAG3> (3: « F »).

note: type: Plain text
en: The fifth byte identifies the architecture for this binary:
fr: Le cinquième octet indique l'architecture pour ce binaire :

note: type: Plain text
en: This class is invalid.
fr: Cette classe n'est pas valable.

note: type: Plain text
en: This defines the 32-bit architecture.  It supports machines with files and virtual address spaces up to 4 Gigabytes.
fr: Ceci définit une architecture 32 bits. Elle permet d'utiliser des machines avec des espaces d'adressage virtuels et des fichiers d'une taille allant jusqu'à 4 gigaoctets.

note: type: Plain text
en: This defines the 64-bit architecture.
fr: Ceci définit une architecture 64 bits.

note: .Bl -tag -width "ELFDATA2LSB" -compact type: Plain text
en: The sixth byte specifies the data encoding of the processor-specific data in the file.  Currently these encodings are supported:
fr: Le sixième octet indique le codage utilisé pour les données de ce fichier spécifiques au processeur. Actuellement, les codages suivants sont permis :

note: type: Plain text
en: Unknown data format.
fr: Format de données inconnu.

note: type: Plain text
en: Two's complement, little-endian.
fr: Complément à deux, petit boutiste.

note: type: Plain text
en: Two's complement, big-endian.
fr: Complément à deux, gros boutiste.

note: .Bl -tag -width "EV_CURRENT" -compact type: Plain text
en: The seventh byte is the version number of the ELF specification:
fr: Le 7e octet est le numéro de version de la spécification du format ELF :

note: type: Plain text
en: Invalid version.
fr: Version non valable.

note: .El type: Plain text
en: Current version.
fr: Version actuelle.

note: .Bl -tag -width "ELFOSABI_STANDALONE" -compact type: Plain text
en: The eighth byte identifies the operating system and ABI to which the object is targeted.  Some fields in other ELF structures have flags and values that have platform-specific meanings; the interpretation of those fields is determined by the value of this byte.  E.g.:
fr: Le 8e octet identifie le système d'exploitation et l'interface binaire des applications (ABI) auxquels cet objet est destiné. Certains des champs d'autres structures ELF contiennent des valeurs et des drapeaux dont la signification dépend de la plate-forme ; l'interprétation de ces champs dépend de la valeur de cet octet. Par exemple :

note: 0 type: Plain text
en: Same as ELFOSABI_SYSV
fr: Identique à ELFOSABI_SYSV

note: 0 synonym: ELFOSABI_NONE type: Plain text
en: UNIX System V ABI.
fr: ABI UNIX System V.

note: 1 type: Plain text
en: HP-UX ABI.
fr: ABI HP-UX.

note: 2 type: Plain text
en: NetBSD ABI.
fr: ABI NetBSD.

note: 3 .TP .BR ELFOSABI_HURD Hurd ABI. 4 .BR ELFOSABI_86OPEN 86Open Common IA32 ABI. 5 type: Plain text
en: Linux ABI.
fr: ABI Linux.

note: 6 .TP .BR ELFOSABI_MONTEREY Monterey project ABI. Now replaced by ELFOSABI_AIX 7 type: Plain text
en: Solaris ABI.
fr: ABI Solaris.

note: 8 type: Plain text
en: IRIX ABI.
fr: ABI IRIX.

note: 9 type: Plain text
en: FreeBSD ABI.
fr: ABI FreeBSD.

note: 10 ELFOSABI_MODESTO 11 ELFOSABI_OPENBSD 12 type: Plain text
en: TRU64 UNIX ABI.
fr: ABI UNIX TRU64.

note: 97 type: Plain text
en: ARM architecture ABI.
fr: ABI de l'architecture ARM.

note: 255 .El type: Plain text
en: Stand-alone (embedded) ABI.
fr: ABI autonome (embarqué).

note: type: Plain text
en: The ninth byte identifies the version of the ABI to which the object is targeted.  This field is used to distinguish among incompatible versions of an ABI.  The interpretation of this version number is dependent on the ABI identified by the B<EI_OSABI> field.  Applications conforming to this specification use the value 0.
fr: Le 9e octet identifie la version de l'interface binaire des applications (ABI) à laquelle cet objet est destiné. Ce champ permet de différencier des versions incompatibles d'une même ABI. L'interprétation de ce numéro de version dépend de l'ABI indiquée par le champ B<EI_OSABI>. Les applications respectant cette spécification utilisent la valeur 0.

note: As reported by Yuri Kozlov and confirmed by Mike Frysinger, EI_BRAND is not in GABI (http://www.sco.com/developers/gabi/latest/ch4.eheader.html) It looks to be a BSDism .TP .BR EI_BRAND Start of architecture identification. type: Plain text
en: Start of padding.  These bytes are reserved and set to zero.  Programs which read them should ignore them.  The value for B<EI_PAD> will change in the future if currently unused bytes are given meanings.
fr: Début de remplissage. Ces octets sont réservés et positionnés à zéro. Les programmes qui les lisent ne doivent pas en tenir compte. La valeur de B<EI_PAD> sera modifiée dans le futur si l'on décide de donner une signification à des octets actuellement inutilisés.

note: .El type: Plain text
en: The size of the I<e_ident> array.
fr: Taille du tableau I<e_ident>.

note: type: Plain text
en: This member of the structure identifies the object file type:
fr: Ce membre de la structure identifie le type de fichier objet :

note: type: Plain text
en: An unknown type.
fr: Type inconnu.

note: type: Plain text
en: A relocatable file.
fr: Fichier repositionnable.

note: type: Plain text
en: An executable file.
fr: Fichier exécutable.

note: type: Plain text
en: A shared object.
fr: Objet partagé.

note: type: Plain text
en: A core file.
fr: Fichier core.

note: type: Plain text
en: This member specifies the required architecture for an individual file.  E.g.:
fr: Ce membre indique l'architecture nécessaire à un fichier particulier. Par exemple :

note: 0 type: Plain text
en: An unknown machine.
fr: Machine inconnue.

note: 8 EM_S370 9 .TP .BR EM_MIPS_RS4_BE MIPS RS4000 (big-endian only). Deprecated. 10 EM_MIPS_RS3_LE (MIPS R3000 little-endian) type: Plain text
en: MIPS RS3000 (big-endian only).
fr: MIPS RS3000 (uniquement gros-boutiste).

note: 18 type: Plain text
en: SPARC with enhanced instruction set.
fr: SPARC avec jeu d'instructions étendu.

note: 21 type: Plain text
en: PowerPC 64-bit.
fr: PowerPC 64 bits.

note: 40 type: Plain text
en: Advanced RISC Machines
fr: Machines de technologie RISC avancées

note: 43 type: Plain text
en: SPARC v9 64-bit.
fr: SPARC v9 64 bits.

note: .Bl -tag -width "EV_CURRENT" -compact type: Plain text
en: This member identifies the file version:
fr: Ce membre indique la version du fichier :

note: type: Plain text
en: This member gives the virtual address to which the system first transfers control, thus starting the process.  If the file has no associated entry point, this member holds zero.
fr: Ce membre indique l'adresse virtuelle à laquelle le système transfère initialement le contrôle, démarrant ainsi le processus. Si ce fichier ne comporte pas de point d'entrée, ce champ contient zéro.

note: type: Plain text
en: This member holds the program header table's file offset in bytes.  If the file has no program header table, this member holds zero.
fr: Ce membre contient le déplacement en octets de la table contenant l'en-tête de programme. Si ce fichier ne comporte pas de table d'en-tête de programme, ce champ contient zéro.

note: type: Plain text
en: This member holds the section header table's file offset in bytes.  If the file has no section header table, this member holds zero.
fr: Ce membre contient le déplacement en octets de la table des en-têtes de sections. Si ce fichier ne comporte pas de table des en-têtes des sections, ce champ contient zéro.

note: type: Plain text
en: This member holds processor-specific flags associated with the file.  Flag names take the form EF_`machine_flag'.  Currently no flags have been defined.
fr: Ce membre contient des drapeaux spécifiques au processeur. Le nom de ces drapeaux est de la forme EF_machine_drapeau. À l'heure actuelle, aucun drapeau n'a été défini.

note: type: Plain text
en: This member holds the ELF header's size in bytes.
fr: Ce membre contient la taille de l'en-tête ELF en octets.

note: type: Plain text
en: This member holds the size in bytes of one entry in the file's program header table; all entries are the same size.
fr: Ce membre contient la taille en octets d'une entrée de la table d'en-tête de programme ; toutes les entrées sont de même taille.

note: type: Plain text
en: This member holds the number of entries in the program header table.  Thus the product of I<e_phentsize> and I<e_phnum> gives the table's size in bytes.  If a file has no program header, I<e_phnum> holds the value zero.
fr: Ce membre contient le nombre d'entrées de la table d'en-tête de programme. Ainsi, la taille en octets de la table pourra être obtenue en multipliant I<e_phentsize> par I<e_phnum>. Si un fichier ne comporte pas d'en-tête de programme, I<e_phnum> contiendra la valeur zéro.

note: This is a Linux extension, added in Linux 2.6.34. .Bl -tag -width "PN_XNUM" type: Plain text
en: If the number of entries in the program header table is larger than or equal to B<PN_XNUM> (0xffff), this member holds B<PN_XNUM> (0xffff) and the real number of entries in the program header table is held in the I<sh_info> member of the initial entry in section header table.  Otherwise, the I<sh_info> member of the initial entry contains the value zero.
fr: Si le nombre d'entrées de la table d'en-tête de programme est supérieur ou égal à B<PN_XNUM> (0xffff), ce membre contient B<PN_XNUM> (0xffff) et le nombre réel d'entrées dans la table d'en-tête de programme est stocké dans le membre I<sh_info> de l'entrée initiale de la table des en-têtes de sections. Dans le cas contraire, le membre I<sh_info> de l'entrée initiale de la table des en-têtes de sections contient la valeur zéro.

note: type: Plain text
en: This is defined as 0xffff, the largest number I<e_phnum> can have, specifying where the actual number of program headers is assigned.
fr: Est défini comme 0xffff, le plus grand nombre que I<e_phnum> peut valoir, qui spécifie où le nombre actuel d'en-têtes de programme est assigné.

note: type: Plain text
en: This member holds a sections header's size in bytes.  A section header is one entry in the section header table; all entries are the same size.
fr: Ce membre contient la taille en octets d'un en-tête de section. Un en-tête de section est une entrée de la table des en-têtes de sections ; toutes les entrées sont de même taille.

note: type: Plain text
en: This member holds the number of entries in the section header table.  Thus the product of I<e_shentsize> and I<e_shnum> gives the section header table's size in bytes.  If a file has no section header table, I<e_shnum> holds the value of zero.
fr: Ce membre contient le nombre d'entrées de la table des en-têtes de sections. Ainsi, la taille en octets de la table des en-têtes de sections pourra être obtenue en multipliant I<e_shentsize> par I<e_shnum>. Si un fichier ne comporte pas de table des en-têtes de sections, le champ I<e_shnum> contiendra zéro.

note: type: Plain text
en: If the number of entries in the section header table is larger than or equal to B<SHN_LORESERVE> (0xff00), I<e_shnum> holds the value zero and the real number of entries in the section header table is held in the I<sh_size> member of the initial entry in section header table.  Otherwise, the I<sh_size> member of the initial entry in the section header table holds the value zero.
fr: Si le nombre d'entrées de la table des en-têtes de sections est supérieur ou égal à B<SHN_LORESERVE> (0xff00), I<e_shnum> contient la valeur zéro et le nombre réel d'entrées dans la table des en-têtes de sections est stocké dans le membre I<sh_size> de l'entrée initiale de la table des en-têtes de sections. Dans le cas contraire, le membre I<sh_size> de l'entrée initiale de la table des en-têtes de sections contient la valeur zéro.

note: type: Plain text
en: This member holds the section header table index of the entry associated with the section name string table.  If the file has no section name string table, this member holds the value B<SHN_UNDEF>.
fr: Ce membre contient l'indice dans la table des en-têtes de sections de l'entrée associée à la table des chaînes de noms des sections. Si le fichier ne comporte pas de table des chaînes de noms des sections, ce champ contiendra la valeur B<SHN_UNDEF>.

note: type: Plain text
en: If the index of section name string table section is larger than or equal to B<SHN_LORESERVE> (0xff00), this member holds B<SHN_XINDEX> (0xffff) and the real index of the section name string table section is held in the I<sh_link> member of the initial entry in section header table.  Otherwise, the I<sh_link> member of the initial entry in section header table contains the value zero.
fr: Si l'indice de la section de la table des chaînes de noms des sections est supérieur ou égal à B<SHN_LORESERVE> (0xff00), ce membre contient la valeur B<SHN_XINDEX> (0xffff) et l'indice réel de la section de la table des chaînes de noms des sections est stocké dans le membre I<sh_link> de l'entrée initiale de la table des en-têtes de sections. Dans le cas contraire, le membre I<sh_link> de l'entrée initiale de la table des en-têtes de sections contient la valeur zéro.

note: type: Plain text
en: This value marks an undefined, missing, irrelevant, or otherwise meaningless section reference.  For example, a symbol "defined" relative to section number B<SHN_UNDEF> is an undefined symbol.
fr: Cette valeur indique une référence de section non définie, manquante, non pertinente ou, d'une façon ou d'une autre, sans signification. Par exemple, un symbole «\ defined\ » se rapportant à la section de numéro B<SHN_UNDEF> est un symbole indéfini.

note: type: Plain text
en: This value specifies the lower bound of the range of reserved indices.
fr: Cette valeur indique la borne inférieure de la plage des indices réservés.

note: type: Plain text
en: Values greater than or equal to B<SHN_HIPROC> are reserved for processor-specific semantics.
fr: Les valeurs supérieures ou égales à B<SHN_HIPROC> sont réservées à des sémantiques spécifiques au processeur.

note: type: Plain text
en: Values less than or equal to B<SHN_LOPROC> are reserved for processor-specific semantics.
fr: Les valeurs inférieures ou égales à B<SHN_LOPROC> sont réservées à des sémantiques spécifiques au processeur.

note: type: Plain text
en: This value specifies absolute values for the corresponding reference.  For example, symbols defined relative to section number B<SHN_ABS> have absolute values and are not affected by relocation.
fr: Cette valeur indique que les références correspondantes sont des valeurs absolues. Par exemple, les symboles définis par rapport à une section B<SHN_ABS> ont des valeurs absolues et ne sont pas affectées par le repositionnement.

note: type: Plain text
en: Symbols defined relative to this section are common symbols, such as Fortran COMMON or unallocated C external variables.
fr: Les symboles définis par rapport à cette section sont des symboles communs, comme par exemple des COMMON Fortran ou des variables externes C non allouées.

note: type: Plain text
en: This value specifies the upper bound of the range of reserved indices between B<SHN_LORESERVE> and B<SHN_HIRESERVE>, inclusive; the values do not reference the section header table.  That is, the section header table does I<not> contain entries for the reserved indices.
fr: Cette valeur indique la borne supérieure de la plage des indices réservés entre B<SHN_LORESERVE> et B<SHN_HIRESERVE>, inclus ; ces valeurs ne sont pas des références de la table des en-têtes des sections. Autrement dit, la table des en-têtes de sections ne contient I<pas> d'entrée pour les indices réservés.

note: type: Plain text
en: An executable or shared object file's program header table is an array of structures, each describing a segment or other information the system needs to prepare the program for execution.  An object file I<segment> contains one or more I<sections>.  Program headers are meaningful only for executable and shared object files.  A file specifies its own program header size with the ELF header's I<e_phentsize> and I<e_phnum> members.  The ELF program header is described by the type I<Elf32_Phdr> or I<Elf64_Phdr> depending on the architecture:
fr: La table d'en-tête de programme d'un exécutable ou d'un fichier objet partagé est un tableau de structures, chacune d'entre elles décrivant un segment ou d'autres informations dont le système a besoin pour préparer l'exécution du programme. Un I<segment> de fichier objet contient une ou plusieurs I<sections>. L'en-tête de programme n'a de sens que pour les fichiers objets partagés ou les fichiers exécutables. Un fichier indique la taille de son propre en-tête de programme à l'aide des membres I<e_phentsize> et I<e_phnum> de l'en-tête ELF. Selon l'architecture, l'en-tête de programme ELF est représenté par un type I<Elf32_Phdr> ou un type I<Elf64_Phdr> :

note: .Bl -tag -width "p_offset" type: Plain text
en: The main difference between the 32-bit and the 64-bit program header lies in the location of the I<p_flags> member in the total struct.
fr: La principale différence entre l'en-tête d'un programme 32 bits et l'en-tête d'un programme 64 bits repose sur emplacement du champ I<p_flags> au sein de la structure complète.

note: .Bl -tag -width "PT_DYNAMIC" type: Plain text
en: This member of the Phdr struct tells what kind of segment this array element describes or how to interpret the array element's information.
fr: Ce membre de la structure Phdr indique le type de segment décrit par cet élément de tableau ou comment interpréter ses informations.

note: type: Plain text
en: The array element is unused and the other members' values are undefined.  This lets the program header have ignored entries.
fr: Cet élément du tableau est inutilisé et les valeurs des autres membres ne sont pas définis. Cela permet à l'en-tête de programme de contenir des entrées qui ne sont pas prises en compte.

note: type: Plain text
en: The array element specifies a loadable segment, described by I<p_filesz> and I<p_memsz>.  The bytes from the file are mapped to the beginning of the memory segment.  If the segment's memory size I<p_memsz> is larger than the file size I<p_filesz>, the "extra" bytes are defined to hold the value 0 and to follow the segment's initialized area.  The file size may not be larger than the memory size.  Loadable segment entries in the program header table appear in ascending order, sorted on the I<p_vaddr> member.
fr: Cet élément du tableau indique un segment chargeable, décrit par I<p_filesz> et I<p_memsz>. Les octets du fichier sont projetés au début du segment mémoire. Si la taille mémoire du segment I<p_memsz> est plus grande que la taille du fichier I<p_filesz>, les octets «\ supplémentaires\ » sont définis comme contenant la valeur 0 et placés à la suite de la zone initialisée du segment. La taille du fichier ne peut être supérieure à la taille de la mémoire. Dans la table d'en-tête de programme, les entrées de segments chargeables sont indiquées par ordre croissant, classées selon le membre I<p_vaddr>.

note: type: Plain text
en: The array element specifies dynamic linking information.
fr: L'élément de tableau contient des informations de liaison dynamique.

note: type: Plain text
en: The array element specifies the location and size of a null-terminated pathname to invoke as an interpreter.  This segment type is meaningful only for executable files (though it may occur for shared objects).  However it may not occur more than once in a file.  If it is present, it must precede any loadable segment entry.
fr: L'élément de tableau contient l'emplacement et la taille du nom de chemin, terminé par un caractère « null », utilisé pour invoquer l'interpréteur. Ce type de segment n'a de sens que pour des fichiers exécutables (bien qu'il puisse être présent dans des objets partagés). Il ne peut être présent qu'une seule fois dans un fichier. S'il est présent, il doit précéder chaque entrée de segment chargeable.

note: type: Plain text
en: The array element specifies the location and size for auxiliary information.
fr: L'élément de tableau contient l'emplacement et la taille d'informations auxiliaires.

note: type: Plain text
en: This segment type is reserved but has unspecified semantics.  Programs that contain an array element of this type do not conform to the ABI.
fr: Ce type de segment est réservé, mais sa sémantique n'est pas définie. Les programmes contenant un tel élément de tableau ne sont pas conformes à l'interface binaire (ABI).

note: type: Plain text
en: The array element, if present, specifies the location and size of the program header table itself, both in the file and in the memory image of the program.  This segment type may not occur more than once in a file.  Moreover, it may occur only if the program header table is part of the memory image of the program.  If it is present, it must precede any loadable segment entry.
fr: L'élément de tableau, s'il est présent, contiendra l'emplacement et la taille de la table d'en-tête de programme elle-même, à la fois dans le fichier et dans l'image mémoire du programme. Ce type de segment ne peut être présent qu'une seule fois dans un fichier. Qui plus est, il ne peut être présent que si l'en-tête de programme fait partie de l'image mémoire du programme. S'il est présent, il doit précéder chaque entrée de segment chargeable.

note: type: Plain text
en: Values greater than or equal to B<PT_HIPROC> are reserved for processor-specific semantics.
fr: Les valeurs supérieures ou égales à B<PT_HIPROC> sont réservées à des sémantiques spécifiques au processeur.

note: type: Plain text
en: Values less than or equal to B<PT_LOPROC> are reserved for processor-specific semantics.
fr: Les valeurs inférieures ou égales à B<PT_LOPROC> sont réservées à des sémantiques spécifiques au processeur.

note: .El type: Plain text
en: GNU extension which is used by the Linux kernel to control the state of the stack via the flags set in the I<p_flags> member.
fr: Extension GNU qui est utilisée par le noyau de Linux pour contrôler l'état de la pile via l'indicateur positionné dans le membre I<p_flags>.

note: type: Plain text
en: This member holds the offset from the beginning of the file at which the first byte of the segment resides.
fr: Ce membre contient le déplacement du premier octet du segment par rapport au début du fichier.

note: type: Plain text
en: This member holds the virtual address at which the first byte of the segment resides in memory.
fr: Ce membre contient l'adresse virtuelle à laquelle se trouve en mémoire le premier octet du segment.

note: type: Plain text
en: On systems for which physical addressing is relevant, this member is reserved for the segment's physical address.  Under BSD this member is not used and must be zero.
fr: Su les systèmes pour lesquels l'adresse physique est pertinente, ce membre est réservé pour l'adresse physique du segment. Sous BSD, ce champ n'est pas utilisé et doit avoir la valeur zéro.

note: type: Plain text
en: This member holds the number of bytes in the file image of the segment.  It may be zero.
fr: Ce membre contient la taille en octets dans l'image fichier de ce segment. Il peut être égal à zéro.

note: type: Plain text
en: This member holds the number of bytes in the memory image of the segment.  It may be zero.
fr: Ce membre contient la taille en octets de l'image mémoire de ce segment. Il peut être égal à zéro.

note: .Bl -tag -width "PF_X" -compact type: Plain text
en: This member holds a bit mask of flags relevant to the segment:
fr: Ce membre contient un masque de bits d'options relatives à ce segment :

note: type: Plain text
en: An executable segment.
fr: Segment exécutable.

note: type: Plain text
en: A writable segment.
fr: Segment accessible en écriture.

note: type: Plain text
en: A readable segment.
fr: Segment accessible en lecture.

note: type: Plain text
en: A text segment commonly has the flags B<PF_X> and B<PF_R>.  A data segment commonly has B<PF_X>, B<PF_W> and B<PF_R>.
fr: Un segment de texte est souvent affecté des drapeaux B<PF_X> et B<PF_R>. Un segment de données est souvent affecté des drapeaux B<PF_X>, B<PF_W> et B<PF_R>.

note: .El type: Plain text
en: This member holds the value to which the segments are aligned in memory and in the file.  Loadable process segments must have congruent values for I<p_vaddr> and I<p_offset>, modulo the page size.  Values of zero and one mean no alignment is required.  Otherwise, I<p_align> should be a positive, integral power of two, and I<p_vaddr> should equal I<p_offset>, modulo I<p_align>.
fr: Ce membre contient la valeur selon laquelle les segments sont alignés en mémoire et dans le fichier. Pour des segments de processus chargeables, les valeurs I<p_vaddr> et I<p_offset> doivent être congrues, modulo la taille de la page. Des valeurs de zéro ou de un indiquent qu'aucun alignement n'est nécessaire. Sinon, I<p_align> doit être un nombre positif, puissance entière de deux et I<p_vaddr> doit être égal à I<p_offset> modulo I<p_align>.

note: type: Plain text
en: A file's section header table lets one locate all the file's sections.  The section header table is an array of I<Elf32_Shdr> or I<Elf64_Shdr> structures.  The ELF header's I<e_shoff> member gives the byte offset from the beginning of the file to the section header table.  I<e_shnum> holds the number of entries the section header table contains.  I<e_shentsize> holds the size in bytes of each entry.
fr: La table des en-têtes de sections d'un fichier permet de retrouver toutes les sections du fichier. C'est un tableau de structures I<Elf32_Shdr> ou I<Elf64_Shdr>. Le champ I<e_shoff> de l'en-tête ELF donne son déplacement en octets depuis le début du fichier. I<e_shnum> contient le nombre d'entrées que contient la table des en-têtes de sections. I<e_shentsize> contient la taille en octets de chaque entrée.

note: .Bl -tag -width "SHN_LORESERVE" type: Plain text
en: A section header table index is a subscript into this array.  Some section header table indices are reserved: the initial entry and the indices between B<SHN_LORESERVE> and B<SHN_HIRESERVE>.  The initial entry is used in ELF extensions for I<e_phnum>, I<e_shnum> and I<e_strndx>; in other cases, each field in the initial entry is set to zero.  An object file does not have sections for these special indices:
fr: Un indice de la table des en-têtes de sections est un indice de ce tableau. Certains de ces indices de table des en-têtes de sections sont réservés : l'entrée initiale et toutes les entrées comprises entre B<SHN_LORESERVE> et B<SHN_HIRESERVE>. L'entrée initiale est utilisée par des extensions ELF pour I<e_phnum>, I<e_shnum> et I<e_strndx> ; dans les autres cas, chaque champ de l'entrée initiale est mis à zéro. Un fichier objet ne contient pas de section correspondant à ces indices spéciaux :

note: type: Plain text
en: This value marks an undefined, missing, irrelevant, or otherwise meaningless section reference.
fr: Cette valeur indique une référence de section non définie, manquante, non pertinente ou, d'une manière ou d'une autre, sans signification.

note: type: Plain text
en: This value specifies the absolute value for the corresponding reference.  For example, a symbol defined relative to section number B<SHN_ABS> has an absolute value and is not affected by relocation.
fr: Cette valeur définit la valeur absolue de la référence correspondante. Par exemple, un symbole défini par rapport à la section numéro B<SHN_ABS> a une valeur absolue et n'est pas affecté par un repositionnement.

note: type: Plain text
en: Symbols defined relative to this section are common symbols, such as FORTRAN COMMON or unallocated C external variables.
fr: Les symboles définis par rapport à cette section sont des symboles communs, comme par exemple des COMMON Fortran ou des variables externes C non allouées.

note: type: Plain text
en: This value specifies the upper bound of the range of reserved indices.  The system reserves indices between B<SHN_LORESERVE> and B<SHN_HIRESERVE>, inclusive.  The section header table does not contain entries for the reserved indices.
fr: Cette valeur indique la borne supérieure de la plage des indices réservés. Le système réserve les indices compris entre B<SHN_LORESERVE> et B<SHN_HIRESERVE>, inclus. La table des en-têtes de sections ne contient pas d'entrée pour les indices réservés.

note: type: Plain text
en: The section header has the following structure:
fr: L'en-tête de section a la structure suivante :

note: .Bl -tag -width "sh_addralign" type: Plain text
en: No real differences exist between the 32-bit and 64-bit section headers.
fr: Il n'y a pas de réelle différence entre les en-têtes des sections 32 bits et 64 bits.

note: type: Plain text
en: This member specifies the name of the section.  Its value is an index into the section header string table section, giving the location of a null-terminated string.
fr: Ce membre indique le nom de la section. Sa valeur est un indice de la table des chaînes des en-têtes de sections, contenant l'emplacement d'une chaîne terminée par un caractère nul.

note: .Bl -tag -width "SHT_PROGBITS" type: Plain text
en: This member categorizes the section's contents and semantics.
fr: Ce membre définit le contenu et la sémantique de la section.

note: type: Plain text
en: This value marks the section header as inactive.  It does not have an associated section.  Other members of the section header have undefined values.
fr: Cette valeur indique que cet en-tête de section est inactif. Il n'est donc associé à aucune section. Les valeurs des autres champs de l'en-tête de section ne sont pas définies.

note: type: Plain text
en: This section holds information defined by the program, whose format and meaning are determined solely by the program.
fr: Cette section contient des informations définies par le programme, dont le format et le sens ne sont déterminés que par celui-ci.

note: type: Plain text
en: This section holds a symbol table.  Typically, B<SHT_SYMTAB> provides symbols for link editing, though it may also be used for dynamic linking.  As a complete symbol table, it may contain many symbols unnecessary for dynamic linking.  An object file can also contain a B<SHT_DYNSYM> section.
fr: Cette section contient une table de symboles. Typiquement, B<SHT_SYMTAB> contient des symboles pour l'édition de liens, bien qu'elle puisse aussi être utilisée pour la liaison dynamique. Comme il s'agit d'une table de symboles complète, elle peut contenir de nombreux symboles inutiles à la liaison dynamique. Un fichier objet peut aussi contenir une section B<SHT_DYNSYM>.

note: type: Plain text
en: This section holds a string table.  An object file may have multiple string table sections.
fr: Cette section contient une table de chaînes. Un fichier objet peut contenir plusieurs sections de ce type.

note: type: Plain text
en: This section holds relocation entries with explicit addends, such as type I<Elf32_Rela> for the 32-bit class of object files.  An object may have multiple relocation sections.
fr: Cette section contient des entrées de repositionnement ayant des additifs explicites, par exemple les entrées du type I<Elf32_Rela> pour les fichiers objets 32 bits. Un objet peut avoir plusieurs sections de ce type.

note: type: Plain text
en: This section holds a symbol hash table.  An object participating in dynamic linking must contain a symbol hash table.  An object file may have only one hash table.
fr: Cette section contient une table de hachage pour les symboles. Un objet participant à une liaison dynamique doit en contenir une. Un fichier objet ne peut contenir qu'une seule table de hachage.

note: type: Plain text
en: This section holds information for dynamic linking.  An object file may have only one dynamic section.
fr: Cette section contient les informations de liaison dynamique. Un fichier objet ne peut contenir qu'une seule section dynamique.

note: type: Plain text
en: This section holds information that marks the file in some way.
fr: Cette section contient des informations servant à marquer le fichier d'une façon ou d'une autre.

note: type: Plain text
en: A section of this type occupies no space in the file but otherwise resembles B<SHT_PROGBITS>.  Although this section contains no bytes, the I<sh_offset> member contains the conceptual file offset.
fr: Une section de ce type ressemble à B<SHT_PROGBITS> mais n'occupe pas d'espace dans le fichier. Bien que cette section ne contienne aucun octet, le membre I<sh_offset> contient son déplacement théorique dans le fichier.

note: type: Plain text
en: This section holds relocation offsets without explicit addends, such as type I<Elf32_Rel> for the 32-bit class of object files.  An object file may have multiple relocation sections.
fr: Cette section contient des entrées de repositionnement sans additif explicite, par exemple du type I<Elf32_Rel> pour les fichiers objets de la classe de 32 bits. Un objet peut contenir plusieurs sections de repositionnement.

note: type: Plain text
en: This section is reserved but has unspecified semantics.
fr: Cette section est réservée et sa sémantique n'est pas définie.

note: type: Plain text
en: This section holds a minimal set of dynamic linking symbols.  An object file can also contain a B<SHT_SYMTAB> section.
fr: Cette section contient un jeu minimum de symboles de liaison dynamique. Un fichier objet peut aussi contenir une section B<SHT_SYMTAB>.

note: type: Plain text
en: This value up to and including B<SHT_HIPROC> is reserved for processor-specific semantics.
fr: Cette valeur et les valeurs suivantes jusqu'à B<SHT_HIPROC> incluse sont réservées à des sémantiques spécifiques au processeur.

note: type: Plain text
en: This value down to and including B<SHT_LOPROC> is reserved for processor-specific semantics.
fr: Cette valeur et les valeurs précédentes depuis B<SHT_LOPROC> incluse sont réservées à des sémantiques spécifiques au processeur.

note: type: Plain text
en: This value specifies the lower bound of the range of indices reserved for application programs.
fr: Cette valeur indique la borne inférieure de la plage des indices réservés aux programmes applicatifs.

note: .El type: Plain text
en: This value specifies the upper bound of the range of indices reserved for application programs.  Section types between B<SHT_LOUSER> and B<SHT_HIUSER> may be used by the application, without conflicting with current or future system-defined section types.
fr: Cette valeur indique la borne supérieure de la plage des indices réservés aux programmes applicatifs. Les types des sections entre B<SHT_LOUSER> et B<SHT_HIUSER> peuvent être utilisés par l'application, sans que cela n'entre en conflit avec les types de section actuels ou futurs définis par le système.

note: .Bl -tag -width "SHF_EXECINSTR" -compact type: Plain text
en: Sections support one-bit flags that describe miscellaneous attributes.  If a flag bit is set in I<sh_flags>, the attribute is "on" for the section.  Otherwise, the attribute is "off" or does not apply.  Undefined attributes are set to zero.
fr: Les sections contiennent des indicateurs sous forme d'un bit décrivant divers attributs. Si, dans I<sh_flags>, le bit correspondant à un indicateur est positionné, l'attribut est «\ activé\ » pour cette section. Sinon, l'attribut est «\ désactivé\ » ou ne s'applique pas. Les attributs non définis sont mis à zéro.

note: type: Plain text
en: This section contains data that should be writable during process execution.
fr: Cette section contient des données qu'il devrait être possible d'écrire durant l'exécution du processus.

note: type: Plain text
en: This section occupies memory during process execution.  Some control sections do not reside in the memory image of an object file.  This attribute is off for those sections.
fr: Cette section est présente en mémoire durant l'exécution du processus. Certaines sections de contrôle ne sont pas présentes dans l'image mémoire d'un fichier objet. Cet attribut est désactivé pour ces sections.

note: type: Plain text
en: This section contains executable machine instructions.
fr: Cette section contient des instructions machine exécutables.

note: type: Plain text
en: All bits included in this mask are reserved for processor-specific semantics.
fr: Tous les bits contenus dans ce masque sont réservés à des sémantiques spécifiques au processeur.

note: type: Plain text
en: If this section appears in the memory image of a process, this member holds the address at which the section's first byte should reside.  Otherwise, the member contains zero.
fr: Si cette section apparaît dans l'image mémoire d'un processus, ce membre contient l'adresse à laquelle le premier octet de la section doit se trouver. Sinon, ce membre contient zéro.

note: type: Plain text
en: This member's value holds the byte offset from the beginning of the file to the first byte in the section.  One section type, B<SHT_NOBITS>, occupies no space in the file, and its I<sh_offset> member locates the conceptual placement in the file.
fr: La valeur de ce membre indique le déplacement du premier octet de la section par rapport au début du fichier. Une section de type B<SHT_NOBITS>, n'occupe pas de place dans le fichier et son champ I<sh_offset> indique son emplacement théorique dans le fichier.

note: type: Plain text
en: This member holds the section's size in bytes.  Unless the section type is B<SHT_NOBITS>, the section occupies I<sh_size> bytes in the file.  A section of type B<SHT_NOBITS> may have a nonzero size, but it occupies no space in the file.
fr: Ce membre contient la taille en octets de la section. À moins que cette section ne soit de type B<SHT_NOBITS>, elle occupe I<sh_size> octets dans le fichier. Une section de type B<SHT_NOBITS> peut avoir une taille non nulle, mais elle n'occupera cependant aucune place dans le fichier.

note: type: Plain text
en: This member holds a section header table index link, whose interpretation depends on the section type.
fr: Ce membre contient un lien vers un indice de la table des en-têtes de sections, son interprétation dépend du type de section.

note: type: Plain text
en: This member holds extra information, whose interpretation depends on the section type.
fr: Ce membre contient des informations complémentaires, son l'interprétation dépend du type de section.

note: type: Plain text
en: Some sections have address alignment constraints.  If a section holds a doubleword, the system must ensure doubleword alignment for the entire section.  That is, the value of I<sh_addr> must be congruent to zero, modulo the value of I<sh_addralign>.  Only zero and positive integral powers of two are allowed.  Values of zero or one mean the section has no alignment constraints.
fr: Certaines sections ont des contraintes d'alignement d'adresse. Si une section contient un mot double, le système doit s'assurer que la section tout entière est alignée sur les mots doubles. Autrement dit, la valeur de I<sh_addr> doit être congrue à zéro, modulo la valeur de I<sh_addralign>. Seules zéro ou des puissances entières positives de deux sont autorisés. Une valeur de zéro ou de un indique qu'aucune contrainte d'alignement ne s'applique à la section.

note: .El type: Plain text
en: Some sections hold a table of fixed-sized entries, such as a symbol table.  For such a section, this member gives the size in bytes for each entry.  This member contains zero if the section does not hold a table of fixed-size entries.
fr: Certaines sections contiennent une table contenant un nombre d'entrées fixe, comme par exemple les tables de symboles. Pour de telles sections, ce champ donne la taille en octets de chaque entrée. Ce membre contient zéro si cette section ne contient pas une table de ce type.

note: .Bl -tag -width ".shstrtab" type: Plain text
en: Various sections hold program and control information:
fr: Diverses sections contiennent des informations de contrôle et sur le programme\ :

note: type: Plain text
en: This section holds uninitialized data that contributes to the program's memory image.  By definition, the system initializes the data with zeros when the program begins to run.  This section is of type B<SHT_NOBITS>.  The attribute types are B<SHF_ALLOC> and B<SHF_WRITE>.
fr: Cette section contient des données non initialisées qui font partie de l'image mémoire du programme. Par définition, le système initialise ces données avec des zéros lorsque le programme démarre. Cette section est du type B<SHT_NOBITS>. Les types de ses attributs sont B<SHF_ALLOC> et B<SHF_WRITE>.

note: type: Plain text
en: This section holds version control information.  This section is of type B<SHT_PROGBITS>.  No attribute types are used.
fr: Cette section contient des informations de suivi des versions. Cette section est du type B<SHT_PROGBITS>. Aucun attribut n'est utilisé.

note: type: Plain text
en: This section holds initialized pointers to the C++ constructor functions.  This section is of type B<SHT_PROGBITS>.  The attribute types are B<SHF_ALLOC> and B<SHF_WRITE>.
fr: Cette section contient des pointeurs initialisés vers des constructeurs C++. Cette section est du type B<SHT_PROGBITS>. Les types de ses attributs sont B<SHF_ALLOC> et B<SHF_WRITE>.

note: type: Plain text
en: This section holds initialized data that contribute to the program's memory image.  This section is of type B<SHT_PROGBITS>.  The attribute types are B<SHF_ALLOC> and B<SHF_WRITE>.
fr: Cette section contient des données faisant partie de l'image mémoire du programme. Elle est du type B<SHT_PROGBITS>. Les types de ses attributs sont B<SHF_ALLOC> et B<SHF_WRITE>.

note: type: Plain text
en: This section holds information for symbolic debugging.  The contents are unspecified.  This section is of type B<SHT_PROGBITS>.  No attribute types are used.
fr: Cette section contient des données de débogage symbolique. Son contenu n'est pas précisé. Elle est du type B<SHT_PROGBITS>. Aucun type d'attribut n'est utilisé.

note: type: Plain text
en: This section holds initialized pointers to the C++ destructor functions.  This section is of type B<SHT_PROGBITS>.  The attribute types are B<SHF_ALLOC> and B<SHF_WRITE>.
fr: Cette section contient des pointeurs initialisés vers des destructeurs C++. Elle est du type B<SHT_PROGBITS>. Les types de ses attributs sont B<SHF_ALLOC> et B<SHF_WRITE>.

note: type: Plain text
en: This section holds dynamic linking information.  The section's attributes will include the B<SHF_ALLOC> bit.  Whether the B<SHF_WRITE> bit is set is processor-specific.  This section is of type B<SHT_DYNAMIC>.  See the attributes above.
fr: Cette section contient des informations de liaison dynamique. Les attributs de cette section comprennent le bit B<SHF_ALLOC>. Le positionnement du bit B<SHF_WRITE> est spécifique au processeur. Cette section est du type B<SHT_DYNAMIC>. Voir ci-dessus pour les attributs.

note: type: Plain text
en: This section holds strings needed for dynamic linking, most commonly the strings that represent the names associated with symbol table entries.  This section is of type B<SHT_STRTAB>.  The attribute type used is B<SHF_ALLOC>.
fr: Cette section contient les chaînes nécessaires à la liaison dynamique, le plus souvent les chaînes représentant les noms associés aux entrées de la table des symboles. Cette section est du type B<SHT_STRTAB>. Le type d'attribut utilisé est B<SHF_ALLOC>.

note: type: Plain text
en: This section holds the dynamic linking symbol table.  This section is of type B<SHT_DYNSYM>.  The attribute used is B<SHF_ALLOC>.
fr: Cette section contient la table des symboles de liaison dynamique. Cette section est du type B<SHT_DYNSYM>. Le type d'attribut utilisé est B<SHF_ALLOC>.

note: type: Plain text
en: This section holds executable instructions that contribute to the process termination code.  When a program exits normally the system arranges to execute the code in this section.  This section is of type B<SHT_PROGBITS>.  The attributes used are B<SHF_ALLOC> and B<SHF_EXECINSTR>.
fr: Cette section contient des instructions exécutables qui font partie du code de fin du processus. Lorsqu'un programme se termine normalement, le système organise l'exécution du code de cette section. Elle est du type B<SHT_PROGBITS>. Les attributs utilisés sont B<SHF_ALLOC> et B<SHF_EXECINSTR>.

note: type: Plain text
en: This section holds the version symbol table, an array of I<ElfN_Half> elements.  This section is of type B<SHT_GNU_versym>.  The attribute type used is B<SHF_ALLOC>.
fr: Cette section contient la table des symboles de version, tableau d'éléments I<ElfN_Half>. Cette section est du type B<SHT_GNU_versym>. Le type d'attribut utilisé est B<SHF_ALLOC>.

note: type: Plain text
en: This section holds the version symbol definitions, a table of I<ElfN_Verdef> structures.  This section is of type B<SHT_GNU_verdef>.  The attribute type used is B<SHF_ALLOC>.
fr: Cette section contient les définitions de version de symboles, une table de structures  I<ElfN_Verdef>. Cette section est du type B<SHT_GNU_verdef>. Le type d''attribut utilisé est B<SHF_ALLOC>.

note: type: Plain text
en: This section holds the version symbol needed elements, a table of I<ElfN_Verneed> structures.  This section is of type B<SHT_GNU_versym>.  The attribute type used is B<SHF_ALLOC>.
fr: Cette section contient la version de symbole des éléments nécessaires, une table de structures I<ElfN_Verneed>. Cette section est type B<SHT_GNU_versym>. Le type d'attribut utilisé est B<SHF_ALLOC>.

note: type: Plain text
en: This section holds the global offset table.  This section is of type B<SHT_PROGBITS>.  The attributes are processor-specific.
fr: Cette section contient la table globale des déplacements. Elle est du type B<SHT_PROGBITS>. Les attributs sont spécifiques au processeur.

note: type: Plain text
en: This section holds a symbol hash table.  This section is of type B<SHT_HASH>.  The attribute used is B<SHF_ALLOC>.
fr: Cette section contient la table de hachage des symboles. Elle est du type B<SHT_HASH>. L'attribut utilisé est B<SHF_ALLOC>.

note: type: Plain text
en: This section holds executable instructions that contribute to the process initialization code.  When a program starts to run the system arranges to execute the code in this section before calling the main program entry point.  This section is of type B<SHT_PROGBITS>.  The attributes used are B<SHF_ALLOC> and B<SHF_EXECINSTR>.
fr: Cette section contient des instructions exécutables qui font partie du code d'initialisation du processus. Lorsqu'un programme démarre, le système organise l'exécution du code de cette section avant d'appeler le point d'entrée principal du programme. Cette section est du type B<SHT_PROGBITS>. Les attributs utilisés sont B<SHF_ALLOC> et B<SHF_EXECINSTR>.

note: type: Plain text
en: This section holds the pathname of a program interpreter.  If the file has a loadable segment that includes the section, the section's attributes will include the B<SHF_ALLOC> bit.  Otherwise, that bit will be off.  This section is of type B<SHT_PROGBITS>.
fr: Cette section contient le chemin vers un interpréteur de programmes. Si le fichier comporte un segment chargeable contenant cette section, les attributs de la section contiendront le bit B<SHF_ALLOC>. Sinon, ce bit sera désactivé. Cette section est du type B<SHT_PROGBITS>.

note: type: Plain text
en: This section holds line number information for symbolic debugging, which describes the correspondence between the program source and the machine code.  The contents are unspecified.  This section is of type B<SHT_PROGBITS>.  No attribute types are used.
fr: Cette section contient des informations sur les numéros de lignes, qui seront utilisées pour le débogage symbolique. Ces informations établissent la correspondance entre le code source du programme et le code machine. Le contenu de cette section n'est pas spécifié. Cette section est du type B<SHT_PROGBITS>. Aucun attribut n'est utilisé.

note: type: Plain text
en: This section holds information in the "Note Section" format.  This section is of type B<SHT_NOTE>.  No attribute types are used.  OpenBSD native executables usually contain a I<.note.openbsd.ident> section to identify themselves, for the kernel to bypass any compatibility ELF binary emulation tests when loading the file.
fr: Cette section contient des informations dans le format «\ Note Section\ ». Elle est de type B<SHT_NOTE>. Aucun attribut n'est utilisé. Les exécutables natifs OpenBSD contiennent en général une section I<.note.openbsd.ident> leur permettant de s'identifier, afin que le noyau court-circuite, lors du chargement du fichier, toutes les vérifications de compatibilité de l'émulation binaire ELF.

note: type: Plain text
en: This section is used in Linux object files for declaring stack attributes.  This section is of type B<SHT_PROGBITS>.  The only attribute used is B<SHF_EXECINSTR>.  This indicates to the GNU linker that the object file requires an executable stack.
fr: Cette section est utilisée dans les fichiers objets de Linux pour déclarer les attributs de la pile. Cette section est du type B<SHT_PROGBITS>. Le seul attribut utilisé est B<SHF_EXECINSTR>. Ceci indique à l'éditeur de liens GNU que le fichier objet requière une pile exécutable.

note: type: Plain text
en: This section holds the procedure linkage table.  This section is of type B<SHT_PROGBITS>.  The attributes are processor-specific.
fr: Cette section contient une table de liaison des procédures. Elle est du type B<SHT_PROGBITS>. Ses attributs sont spécifiques au processeur.

note: type: TP
en: I<.relNAME>
fr: I<.relNOM>

note: type: Plain text
en: This section holds relocation information as described below.  If the file has a loadable segment that includes relocation, the section's attributes will include the B<SHF_ALLOC> bit.  Otherwise the bit will be off.  By convention, "NAME" is supplied by the section to which the relocations apply.  Thus a relocation section for B<.text> normally would have the name B<.rel.text>.  This section is of type B<SHT_REL>.
fr: Cette section contient des informations de repositionnement, comme décrit ci-dessous. Si ce fichier comporte un segment chargeable comprenant du repositionnement, les attributs de la section contiendront le bit B<SHF_ALLOC>. Sinon, ce bit sera désactivé. Par convention, le «\ NOM\ » est fourni par la section à laquelle le repositionnement s'applique. Ainsi, une section de repositionnement pour du B<.text> s'appellera normalement B<.rel.text>. Cette section est du type B<SHT_REL>.

note: type: TP
en: I<.relaNAME>
fr: I<.relaNOM>

note: type: Plain text
en: This section holds relocation information as described below.  If the file has a loadable segment that includes relocation, the section's attributes will include the B<SHF_ALLOC> bit.  Otherwise the bit will be off.  By convention, "NAME" is supplied by the section to which the relocations apply.  Thus a relocation section for B<.text> normally would have the name B<.rela.text>.  This section is of type B<SHT_RELA>.
fr: Cette section contient des informations de repositionnement, comme décrit ci-dessous. Si ce fichier comporte un segment chargeable comprenant du repositionnement, les attributs de la section contiendront le bit B<SHF_ALLOC>. Sinon, ce bit sera désactivé. Par convention, le «\ NOM\ » est fourni par la section à laquelle le repositionnement s'applique. Ainsi, une section de repositionnement pour du B<.text> s'appellera normalement B<.rela.text>. Cette section est du type B<SHT_RELA>.

note: type: Plain text
en: This section holds read-only data that typically contributes to a nonwritable segment in the process image.  This section is of type B<SHT_PROGBITS>.  The attribute used is B<SHF_ALLOC>.
fr: Cette section contient des données en lecture seule, qui feront classiquement partie d'un segment non accessible en écriture dans l'image du processus. Cette section est du type B<SHT_PROGBITS>. L'attribut utilisé est B<SHF_ALLOC>.

note: type: Plain text
en: This section holds section names.  This section is of type B<SHT_STRTAB>.  No attribute types are used.
fr: Cette section contient les noms des sections. Elle est du type B<SHT_STRTAB>. Aucun type d'attribut.

note: type: Plain text
en: This section holds strings, most commonly the strings that represent the names associated with symbol table entries.  If the file has a loadable segment that includes the symbol string table, the section's attributes will include the B<SHF_ALLOC> bit.  Otherwise the bit will be off.  This section is of type B<SHT_STRTAB>.
fr: Cette section contient des chaînes, le plus souvent ces chaînes représentent les noms associés aux entrées de la table des symboles. Si ce fichier comporte un segment chargeable comprenant la table des chaînes de symboles, les attributs de la section contiendront le bit B<SHF_ALLOC>. Sinon, ce bit sera désactivé. Cette section est du type B<SHT_STRTAB>.

note: type: Plain text
en: This section holds a symbol table.  If the file has a loadable segment that includes the symbol table, the section's attributes will include the B<SHF_ALLOC> bit.  Otherwise the bit will be off.  This section is of type B<SHT_SYMTAB>.
fr: Cette section contient une table des symboles. Si ce fichier comporte un segment chargeable contenant la table des symboles, les attributs de la section contiendront le bit B<SHF_ALLOC>. Sinon, ce bit sera désactivé. Cette section est du type B<SHT_SYMTAB>.

note: .El type: Plain text
en: This section holds the "text", or executable instructions, of a program.  This section is of type B<SHT_PROGBITS>.  The attributes used are B<SHF_ALLOC> and B<SHF_EXECINSTR>.
fr: Cette section contient le «\ texte\ », autrement dit les instructions exécutables, d'un programme. Cette section est du type B<SHT_PROGBITS>. Les attributs utilisés sont B<SHF_ALLOC> et B<SHF_EXECINSTR>.

note: type: Plain text
en: String table sections hold null-terminated character sequences, commonly called strings.  The object file uses these strings to represent symbol and section names.  One references a string as an index into the string table section.  The first byte, which is index zero, is defined to hold a null byte (\(aq\e0\(aq).  Similarly, a string table's last byte is defined to hold a null byte, ensuring null termination for all strings.
fr: Les sections de tables de chaînes contiennent des séquences de caractères terminées par un zéro binaire (« null »), communément appelées chaînes. Le fichier objet utilise ces chaînes pour représenter les noms des symboles et des sections. Le premier octet, qui est l'indice zéro, est défini comme contenant un null. De même, le dernier octet de la table de chaînes est défini comme contenant un null, ce qui assure que toutes les chaînes se termineront bien par un null.

note: type: Plain text
en: An object file's symbol table holds information needed to locate and relocate a program's symbolic definitions and references.  A symbol table index is a subscript into this array.
fr: La table des symboles d'un fichier objet contient les informations permettant de localiser et de repositionner les définitions et références symboliques d'un programme. Un indice dans une table de symbole est un indice de ce tableau.

note: .Bl -tag -width "st_value" type: Plain text
en: The 32-bit and 64-bit versions have the same members, just in a different order.
fr: Les versions 32 bits et 64 bits comportent les mêmes membres, seul leur ordre diffère.

note: type: Plain text
en: This member holds an index into the object file's symbol string table, which holds character representations of the symbol names.  If the value is nonzero, it represents a string table index that gives the symbol name.  Otherwise, the symbol table has no name.
fr: Ce membre contient un indice de la table des chaînes de symboles d'un fichier objet. Cette table contient la représentation sous la forme de chaînes de caractères des noms des symboles. Si la valeur de ce champ est non nulle, il représente l'indice de la table des chaînes qui donne son nom au symbole. Sinon, le symbole n'a pas de nom.

note: type: Plain text
en: This member gives the value of the associated symbol.
fr: Ce membre donne la valeur associée au symbole.

note: type: Plain text
en: Many symbols have associated sizes.  This member holds zero if the symbol has no size or an unknown size.
fr: De nombreux symboles sont associés à des tailles. Ce champ contient zéro si le symbole n'a pas de taille ou si sa taille est inconnue.

note: .Bl -tag -width "STT_SECTION" type: Plain text
en: This member specifies the symbol's type and binding attributes:
fr: Ce membre indique le type de symbole et ses attributs de liaison :

note: type: Plain text
en: The symbol's type is not defined.
fr: Le type de ce symbole n'est pas défini.

note: type: Plain text
en: The symbol is associated with a data object.
fr: Ce symbole est associé à un objet de données.

note: type: Plain text
en: The symbol is associated with a function or other executable code.
fr: Ce symbole est associé à une fonction ou un autre code exécutable.

note: type: Plain text
en: The symbol is associated with a section.  Symbol table entries of this type exist primarily for relocation and normally have B<STB_LOCAL> bindings.
fr: Ce symbole est associé à une section. Les entrées de ce type de la table des symboles existent principalement pour le repositionnement et ont normalement des liaisons B<STB_LOCAL>.

note: type: Plain text
en: By convention, the symbol's name gives the name of the source file associated with the object file.  A file symbol has B<STB_LOCAL> bindings, its section index is B<SHN_ABS>, and it precedes the other B<STB_LOCAL> symbols of the file, if it is present.
fr: Par convention, le nom de ce symbole donne le nom du fichier source associé au fichier objet. Un symbole de ce type a des liaisons B<STB_LOCAL>, son indice de section est B<SHN_ABS>, et, s'il est présent, il précède les autres symboles B<STB_LOCAL> du fichier.

note: type: Plain text
en: This value up to and including B<STT_HIPROC> is reserved for processor-specific semantics.
fr: Cette valeur et les valeurs suivantes jusqu'à B<STT_HIPROC> (valeur comprise) sont réservées à des sémantiques spécifiques au processeur.

note: .El .Bl -tag -width "STB_GLOBAL" type: Plain text
en: This value down to and including B<STT_LOPROC> is reserved for processor-specific semantics.
fr: Cette valeur et les valeurs précédentes depuis B<STT_LOPROC> incluse sont réservées à des sémantiques spécifiques au processeur.

note: type: Plain text
en: Local symbols are not visible outside the object file containing their definition.  Local symbols of the same name may exist in multiple files without interfering with each other.
fr: Les symboles locaux ne sont pas visibles en dehors du fichier objet contenant leur définition. Des symboles locaux de même nom peuvent exister dans plusieurs fichiers sans interférer entre eux.

note: type: Plain text
en: Global symbols are visible to all object files being combined.  One file's definition of a global symbol will satisfy another file's undefined reference to the same symbol.
fr: Les symboles globaux sont visibles de tous les fichiers objets devant être réunis. La définition par un fichier d'un symbole global satisfera une référence non définie d'un autre fichier à ce même symbole.

note: type: Plain text
en: Weak symbols resemble global symbols, but their definitions have lower precedence.
fr: Les symboles faibles ressemblent à des symboles globaux, mais leur définition a une priorité plus faible.

note: type: Plain text
en: This value up to and including B<STB_HIPROC> is reserved for processor-specific semantics.
fr: Cette valeur et les valeurs suivantes jusqu'à B<STB_HIPROC> (valeur comprise) sont réservées à des sémantiques spécifiques au processeur.

note: type: Plain text
en: This value down to and including B<STB_LOPROC> is reserved for processor-specific semantics.
fr: Cette valeur et les valeurs précédentes depuis B<STB_LOPROC> incluse sont réservées à des sémantiques spécifiques au processeur.

note: type: Plain text
en: There are macros for packing and unpacking the binding and type fields:
fr: Il existe des macros permettant de coder et de décoder les champs de type et de liaison\ :

note: type: Plain text
en: B<ELF32_ST_BIND>(info)  or B<ELF64_ST_BIND>(info)  extract a binding from an I<st_info> value.
fr: B<ELF32_ST_BIND>(info) ou B<ELF64_ST_BIND>(info) extrait une liaison d'une valeur I<st_info>.

note: type: Plain text
en: B<ELF32_ST_TYPE>(info)  or B<ELF64_ST_TYPE>(info)
fr: B<ELF32_ST_TYPE>(info) ou B<ELF64_ST_TYPE>(info)

note: type: Plain text
en: extract a type from an I<st_info> value.
fr: extraire un type d'une valeur I<st_info>.

note: type: Plain text
en: B<ELF32_ST_INFO>(bind, type)  or B<ELF64_ST_INFO>(bind, type)
fr: B<ELF32_ST_INFO>(liaison, type) ou B<ELF64_ST_INFO>(liaison, type)

note: type: Plain text
en: convert a binding and a type into an I<st_info> value.
fr: convertir une liaison et un type en une valeur I<st_info>.

note: .Bl -tag -width "STV_PROTECTED" type: Plain text
en: This member defines the symbol visibility.
fr: Ce membre définit la visibilité du symbole.

note: type: Plain text
en: Default symbol visibility rules.
fr: Règles par défaut de visibilité du symbole.

note: type: Plain text
en: Processor-specific hidden class.
fr: Classe caché spécifique au processeur.

note: type: Plain text
en: Symbol is unavailable in other modules.
fr: Le symbole n"est pas disponible dans d'autres modules.

note: type: Plain text
en: Not preemptible, not exported.
fr: Non préemptible, non exporté.

note: type: Plain text
en: There are macros for extracting the visibility type:
fr: Il existe des macros permettant d'extraire le type de visibilité :

note: type: Plain text
en: B<ELF32_ST_VISIBILITY>(other)  or B<ELF64_ST_VISIBILITY>(other)
fr: B<ELF32_ST_VISIBILITY>(autre)  ou B<ELF64_ST_VISIBILITY>(autre)

note: .El type: Plain text
en: Every symbol table entry is "defined" in relation to some section.  This member holds the relevant section header table index.
fr: Chaque entrée de la table des symboles est « définie » en relation avec une section. Ce membre contient l'indice correspondant de la table des en-têtes de sections.

note: type: Plain text
en: Relocation is the process of connecting symbolic references with symbolic definitions.  Relocatable files must have information that describes how to modify their section contents, thus allowing executable and shared object files to hold the right information for a process's program image.  Relocation entries are these data.
fr: Le repositionnement est le processus consistant à relier des références symboliques à des définitions symboliques. Les fichiers repositionnables doivent contenir des informations décrivant comment modifier le contenu de leurs sections, ce qui permet aux fichiers objets partagés et exécutables de détenir les bonnes informations concernant l'image mémoire d'un programme. Les entrées de repositionnement sont ces données.

note: type: Plain text
en: Relocation structures that do not need an addend:
fr: Structures de repositionnement pour lesquelles un additif est nécessaire :

note: type: Plain text
en: Relocation structures that need an addend:
fr: Structures de repositionnement pour lesquelles un additif est nécessaire :

note: type: Plain text
en: This member gives the location at which to apply the relocation action.  For a relocatable file, the value is the byte offset from the beginning of the section to the storage unit affected by the relocation.  For an executable file or shared object, the value is the virtual address of the storage unit affected by the relocation.
fr: Ce membre donne l'emplacement où appliquer l'action de repositionnement. Pour un fichier repositionnable, sa valeur est le déplacement en octets depuis le début de la section jusqu'à l'unité de stockage affectée par le repositionnement. Pour un fichier exécutable ou un objet partagé, sa valeur est l'adresse virtuelle de l'unité de stockage affectée par le repositionnement.

note: type: Plain text
en: This member gives both the symbol table index with respect to which the relocation must be made and the type of relocation to apply.  Relocation types are processor-specific.  When the text refers to a relocation entry's relocation type or symbol table index, it means the result of applying B<ELF[32|64]_R_TYPE> or B<ELF[32|64]_R_SYM>, respectively, to the entry's I<r_info> member.
fr: Ce membre donne à la fois l'indice de la table des symboles par rapport auquel on doit effectuer le repositionnement et le type de repositionnement à appliquer. Les types de repositionnement dépendent du processeur. Lorsque le texte mentionne le type de repositionnement ou l'indice de la table des symboles d'une entrée de repositionnement, il s'agit du résultat de l'application de B<ELF[32|64]_R_TYPE> ou B<ELF[32|64]_R_SYM>, respectivement, au champ I<r_info> de cette entrée.

note: .El type: Plain text
en: This member specifies a constant addend used to compute the value to be stored into the relocatable field.
fr: Ce membre indique un additif constant pour le calcul de la valeur à stocker dans le champ repositionnable.

note: type: Plain text
en: The .dynamic section contains a series of structures that hold relevant dynamic linking information.  The d_tag member controls the interpretation of d_un.
fr: La section .dynamic comporte une série de structures qui contiennent les informations relatives à l'édition de liens dynamique. Le membre d_tag contrôle l'interprétation de d_un.

note: .Bl -tag -width "DT_SYMBOLIC" type: Plain text
en: This member may have any of the following values:
fr: Ce membre peut prendre l'une des trois valeurs suivantes :

note: type: Plain text
en: Marks end of dynamic section
fr: Indique la fin de la section dynamique

note: type: Plain text
en: String table offset to name of a needed library
fr: Décalage dans la table des chaînes vers le nom d'une bibliothèque nécessaire

note: type: Plain text
en: Size in bytes of PLT relocs
fr: Taille en octets des relocations PLT

note: type: Plain text
en: Address of PLT and/or GOT
fr: Adresse de plt et/ou de GOT

note: type: Plain text
en: Address of symbol hash table
fr: Adresse de la table de hachage des symboles

note: type: Plain text
en: Address of string table
fr: Adresse de la table des chaînes

note: type: Plain text
en: Address of symbol table
fr: Adresse de la table des symboles

note: type: Plain text
en: Address of Rela relocs table
fr: Adresse de la table des relocations Rela

note: type: Plain text
en: Size in bytes of Rela table
fr: Taille, en octets, de la table Rela

note: type: Plain text
en: Size in bytes of a Rela table entry
fr: Taille, en octets, d'une entrée de la table Rela

note: type: Plain text
en: Size in bytes of string table
fr: Taille, en octets, de la table des chaînes

note: type: Plain text
en: Size in bytes of a symbol table entry
fr: Taille, en octets, d'une entrée de la table des symboles

note: type: Plain text
en: Address of the initialization function
fr: Adresse de la fonction d'initialisation

note: type: Plain text
en: Address of the termination function
fr: Adresse de la fonction de terminaison

note: type: Plain text
en: String table offset to name of shared object
fr: Déplacement dans la table des chaînes vers le nom de l'objet partagé

note: type: Plain text
en: String table offset to library search path (deprecated)
fr: Déplacement dans la table des chaînes pour le chemin de recherche de la bibliothèque (déprécié)

note: type: Plain text
en: Alert linker to search this shared object before the executable for symbols
fr: Demander à l'éditeur de liens de rechercher les symboles dans cet objet partagé avant l'exécutable

note: type: Plain text
en: Address of Rel relocs table
fr: Adresse de la table des relocations Rel

note: type: Plain text
en: Size in bytes of Rel table
fr: Taille en octets de la table Rel

note: type: Plain text
en: Size in bytes of a Rel table entry
fr: Taille en octets d'une entrée de la table Rel

note: type: Plain text
en: Type of reloc the PLT refers (Rela or Rel)
fr: Type de relocation auquel se réfère PLT (Rela ou Rel)

note: type: Plain text
en: Undefined use for debugging
fr: Utilisation non définie pour le débogage

note: type: Plain text
en: Absence of this indicates no relocs should apply to a nonwritable segment
fr: Son absence indique qu'aucune relocation ne devrait s'appliquer à un segment non accessible en écriture

note: type: Plain text
en: Address of reloc entries solely for the PLT
fr: Adresse des entrées de relocation, uniquement pour la PLT

note: type: Plain text
en: Instruct dynamic linker to process all relocs before transferring control to the executable
fr: Informer l'éditeur de liens dynamique de traiter toutes les relocations avant de transférer le contrôle à l'exécutable

note: type: Plain text
en: String table offset to library search path
fr: Décalage dans la table des chaînes pour le chemin de recherche de la bibliothèque

note: type: Plain text
en: Start of processor-specific semantics
fr: Début des sémantiques spécifiques au processeur

note: type: Plain text
en: End of processor-specific semantics
fr: Fin de la sémantique propre au processeur

note: type: Plain text
en: This member represents integer values with various interpretations.
fr: Ce membre représente des valeurs entières ayant des interprétations diverses.

note: type: Plain text
en: This member represents program virtual addresses.  When interpreting these addresses, the actual address should be computed based on the original file value and memory base address.  Files do not contain relocation entries to fixup these addresses.
fr: Ce membre représente les adresses virtuelles du programme. Lors de l'interprétation de ces adresses, l'adresse réelle doit être calculée en se basant sur la valeur originale du fichier et sur l'adresse de base de la mémoire. Les fichiers ne contiennent pas d'entrées de repositionnement pour corriger ces adresses.

note: .El type: Plain text
en: Array containing all the dynamic structures in the .dynamic section.  This is automatically populated by the linker.
fr: Tableau contenant toutes les structures de la section .dynamic. Ceci est automatiquement rempli par l'éditeur de liens.

note: OpenBSD ELF support first appeared in OpenBSD 1.2, although not all supported platforms use it as the native binary file format. type: Plain text
en: ELF first appeared in System V.  The ELF format is an adopted standard.
fr: ELF est apparu d'abord dans le System V. Le format ELF est un standard adopté.

note: .SH AUTHORS The original version of this manual page was written by .An Jeroen Ruigrok van der Werven .Aq asmodai@FreeBSD.org with inspiration from BSDi's .Bsx .Nm elf man page. type: Plain text
en: The extensions for I<e_phnum>, I<e_shnum> and I<e_strndx> respectively are Linux extensions.  Sun, BSD and AMD64 also support them; for further information, look under SEE ALSO.
fr: Les extensions pour I<e_phnum>, I<e_shnum> et I<e_strndx> sont des extensions Linux. Sun, BSD et AMD64 les gèrent aussi. Pour plus d'informations, veuillez lire la section VOIR AUSSI.

note: type: Plain text
en: Hewlett-Packard, I<Elf-64 Object File Format>.
fr: Hewlett-Packard, I<Format de fichiers Elf-64> (I<Elf-64 Object File Format>).

note: type: Plain text
en: Santa Cruz Operation, I<System V Application Binary Interface>.
fr: Santa Cruz Operation, I<Interface binaire des applications System V> (I<System V Application Binary Interface>).

note: type: Plain text
en: UNIX System Laboratories, "Object Files", I<Executable and Linking Format (ELF)>.
fr: UNIX System Laboratories, "Object Files", I<Format des fichiers exécutables ELF> (I<Executable and Linking Format>)

note: type: Plain text
en: Sun Microsystems, I<Linker and Libraries Guide>.
fr: Sun Microsystems, I<Guide de l'éditeur de liens et des bibliothèques> (I<Linker and Libraries Guide>).

note: type: Plain text
en: AMD64 ABI Draft, I<System V Application Binary Interface AMD64 Architecture Processor Supplement>.
fr: Version préliminaire de l'ABI AMD64 (I<System V Application Binary Interface AMD64 Architecture Processor Supplement>).

note: type: TH
en: 2008-07-17
fr: 17 juillet 2008

note: type: Plain text
en: etext, edata, end - end of program segments
fr: etext, edata, end - Fin des segments de programme

note: type: Plain text
en: The addresses of these symbols indicate the end of various program segments:
fr: Les adresses de ces symboles indiquent la fin de différents segments du programme :

note: type: Plain text
en: This is the first address past the end of the text segment (the program code).
fr: La première adresse après la fin du segment de texte (le code du programme).

note: type: Plain text
en: This is the first address past the end of the initialized data segment.
fr: La première adresse après la fin du segment des données initialisées.

note: type: Plain text
en: This is the first address past the end of the uninitialized data segment (also known as the BSS segment).
fr: La première adresse après la fin du segment des données non initialisées (également connu comme le segment BSS).

note: type: Plain text
en: Although these symbols have long been provided on most UNIX systems, they are not standardized; use with caution.
fr: Bien que ces symboles aient été fournis depuis longtemps par la plupart des systèmes UNIX, ils ne sont pas standard ; utilisez les avec précaution.

note: type: Plain text
en: The program must explicitly declare these symbols; they are not defined in any header file.
fr: Le programme doit déclarer explicitement ces symboles ; ils ne sont définis dans aucun fichier d'en-têtes.

note: type: Plain text
en: On some systems the names of these symbols are preceded by underscores, thus: I<_etext>, I<_edata>, and I<_end>.  These symbols are also defined for programs compiled on Linux.
fr: Sur certains systèmes, les noms de ces symboles sont précédé d'un tiret-bas : I<_etext>, I<_edata> et I<_end>. Ces symboles sont également définis pour les programmes compilés sous Linux.

note: type: Plain text
en: At the start of program execution, the program break will be somewhere near I<&end> (perhaps at the start of the following page).  However, the break will change as memory is allocated via B<brk>(2)  or B<malloc>(3).  Use B<sbrk>(2)  with an argument of zero to find the current value of the program break.
fr: Au début de l'exécution du programme, l’interruption de programme se trouve quelque part près de I<&end> (peut-être au début de la page qui suit). Cependant, l’interruption de programme se déplacera au fur et à mesure que de la mémoire est allouée avec B<brk>(2) ou B<malloc>(3). Utilisez B<sbrk>(2) avec un paramètre nul pour trouver la valeur actuelle de l’interruption de programme.

note: type: Plain text
en: When run, the program below produces output such as the following:
fr: Lors de son exécution, le programme affiche les résultats suivants\ :

note: type: SS
en: Program source
fr: Source du programme

note: type: Plain text
en: ld.so, ld-linux.so* - dynamic linker/loader
fr: ld.so, ld-linux.so* - Chargeur et éditeur de liens dynamique

note: type: Plain text
en: The dynamic linker can be run either indirectly by running some dynamically linked program or library (in which case no command-line options to the dynamic linker can be passed and, in the ELF case, the dynamic linker which is stored in the B<.interp> section of the program is executed) or directly by running:
fr: L'éditeur de liens dynamique peut être lancé indirectement en démarrant un programme lié dynamiquement ou une bibliothèque (dans ce cas, aucune option en ligne de commande ne peut être transmise, et avec ELF, l'éditeur indiqué dans la section B<.interp> du programme est exécuté), ou directement en lançant\ :

note: type: Plain text
en: I</lib/ld-linux.so.*> [OPTIONS] [PROGRAM [ARGUMENTS]]
fr: B</lib/ld-linux.so.*> [OPTIONS] [PROGRAMME [ARGUMENTS]]

note: type: Plain text
en: The programs B<ld.so> and B<ld-linux.so*> find and load the shared libraries needed by a program, prepare the program to run, and then run it.
fr: Les programmes B<ld.so> et B<ld-linux.so*> trouvent et chargent les bibliothèques partagées nécessaires pour un programme, préparent son démarrage, et le lancent.

note: type: Plain text
en: Linux binaries require dynamic linking (linking at run time)  unless the B<-static> option was given to B<ld>(1)  during compilation.
fr: Les binaires Linux nécessitent une édition de liens dynamique (au démarrage) sauf si l'option B<-static> a été indiquée sur la ligne de commande de B<ld> durant la compilation.

note: type: Plain text
en: The program B<ld.so> handles a.out binaries, a format used long ago; B<ld-linux.so*> handles ELF (I</lib/ld-linux.so.1> for libc5, I</lib/ld-linux.so.2> for glibc2), which everybody has been using for years now.  Otherwise both have the same behavior, and use the same support files and programs B<ldd>(1), B<ldconfig>(8)  and I</etc/ld.so.conf>.
fr: Le programme B<ld.so> traite les binaires a.out, un format utilisé il y a bien longtemps\ ; B<ld-linux.so*> traitent les fichiers ELF (I</lib/ld-linux.so.1> pour libc5, I</lib/ld-linux.so.2> pour glibc2), que tout le monde utilise depuis des années. Autrement, les deux programmes ont le même comportement et utilisent les fichiers et programmes B<ldd>(1), B<ldconfig>(8)  et I</etc/ld.so.conf>.

note: type: Plain text
en: When resolving library dependencies, the dynamic linker first inspects each dependency string to see if it contains a slash (this can occur if a library pathname containing slashes was specified at link time).  If a slash is found, then the dependency string is interpreted as a (relative or absolute) pathname, and the library is loaded using that pathname.
fr: Lors de la résolution des dépendances de bibliothèques, l'éditeur de liens dynamique inspecte d'abord chaque chaîne de dépendance à la recherche d'une barre oblique (cela peut arriver si un chemin de bibliothèque contenant des barres obliques a été indiqué au moment du lien). Si une barre oblique est trouvée, alors la chaîne de dépendance est interprétée comme un chemin (relatif ou absolu) et la bibliothèque est chargée en utilisant ce chemin.

note: type: Plain text
en: If a library dependency does not contain a slash, then it is searched for in the following order:
fr: Si une dépendance de bibliothèque de contient pas de barre oblique, alors elle est recherchée dans l'ordre suivant :

note: type: Plain text
en: (ELF only) Using the directories specified in the DT_RPATH dynamic section attribute of the binary if present and DT_RUNPATH attribute does not exist.  Use of DT_RPATH is deprecated.
fr: (ELF seulement) En utilisant les répertoires indiqués dans l'attribut de section dynamique DT_RPATH du fichier binaire s'il est présent et si l'attribut DT_RUNPATH n'existe pas. L'utilisation de DT_RPATH est déconseillée.

note: type: Plain text
en: Using the environment variable B<LD_LIBRARY_PATH>.  Except if the executable is a set-user-ID/set-group-ID binary, in which case it is ignored.
fr: En utilisant la variable d'environnement B<LD_LIBRARY_PATH>, sauf si les bits d'emprunt des identifiants d'utilisateur (I<setuid>) ou de groupe (I<setgid>) de l'exécutable sont non nuls (par souci de simplification, on parlera ci-dessous d'exécutable I<setuid> ou I<setgid>), auquel cas elle est ignorée.

note: type: Plain text
en: (ELF only) Using the directories specified in the DT_RUNPATH dynamic section attribute of the binary if present.
fr: (ELF seulement) En utilisant les répertoires indiqués dans l'attribut de section dynamique DT_RUNPATH du fichier binaire s'il est présent.

note: type: Plain text
en: From the cache file I</etc/ld.so.cache>, which contains a compiled list of candidate libraries previously found in the augmented library path.  If, however, the binary was linked with the B<-z nodeflib> linker option, libraries in the default library paths are skipped.  Libraries installed in hardware capability directories (see below)  are preferred to other libraries.
fr: Depuis le fichier cache I</etc/ld.so.cache>, qui contient une liste compilée de bibliothèques précédemment trouvées dans des chemins par défaut. Si toutefois le fichier binaire a été lié avec l'option B<-z nodeflib> de l'éditeur de liens, les chemins par défaut sont ignorés. Les bibliothèques installées dans les répertoires de capacité matérielle (voir ci-dessous) sont préférées aux autres bibliothèques.

note: type: Plain text
en: In the default path I</lib>, and then I</usr/lib>.  If the binary was linked with the B<-z nodeflib> linker option, this step is skipped.
fr: Dans le répertoire par défaut I</lib>, puis I</usr/lib>. Si le binaire a été lié avec l'option B<-z nodeflib> de l'éditeur de lien, cette étape est sautée.

note: type: SS
en: Rpath token expansion
fr: Développement des mots-clés rpath

note: type: Plain text
en: B<ld.so> understands certain strings in an rpath specification (DT_RPATH or DT_RUNPATH); those strings are substituted as follows
fr: B<ld.so> comprend certaines chaînes dans une spécification rpath (DT_RPATH ou DT_RUNPATH) ; ces chaines sont substituées ainsi :

note: type: TP
en: I<$ORIGIN> (or equivalently I<${ORIGIN}>)
fr: I<$ORIGIN> (ou de manière équivalente I<${ORIGIN}>)

note: type: Plain text
en: This expands to the directory containing the application executable.  Thus, an application located in I<somedir/app> could be compiled with
fr: Ainsi, une application située dans I<un_répertoire/app> peut être compilée avec

note: type: Plain text
en: so that it finds an associated shared library in I<somedir/lib> no matter where I<somedir> is located in the directory hierarchy.  This facilitates the creation of "turn-key" applications that do not need to be installed into special directories, but can instead be unpacked into any directory and still find their own shared libraries.
fr: de sorte qu'elle trouvera une bibliothèque partagée associée dans I<un_répertoire/lib> où que soit situé I<un_répertoire> dans la hiérarchie du répertoire. Cela facilite la création d'applications «\ prêtes à l'emploi\ » qui n'ont pas besoin d'être installées dans un répertoire particulier mais peuvent au contraire être installées dans n'importe quel répertoire et toujours trouver leurs propres bibliothèques partagées.

note: type: TP
en: I<$LIB> (or equivalently I<${LIB}>)
fr: I<$LIB> (ou de manière équivalente I<${LIB}>)

note: type: Plain text
en: This expands to I<lib> or I<lib64> depending on the architecture (e.g., on x86-64, it expands to I<lib64> and on x86-32, it expands to I<lib>).
fr: Est développé en I<lib> ou I<lib64> en fonction de l'architecture (par exemple I<lib64> pour x86-64 ou I<lib> pour x86-32).

note: type: TP
en: I<$PLATFORM> (or equivalently I<${PLATFORM}>)
fr: I<$PLATFORM> (ou de manière équivalente I<${PLATFORM}>)

note: To get an idea of the places that $PLATFORM would match, look at the output of the following: mkdir /tmp/d LD_LIBRARY_PATH=/tmp/d strace -e open /bin/date 2>&1 | grep /tmp/d ld.so lets names be abbreviated, so $O will work for $ORIGIN; Don't do this!! type: Plain text
en: This expands to a string corresponding to the processor type of the host system (e.g., "x86_64").  On some architectures, the Linux kernel doesn't provide a platform string to the dynamic linker.  The value of this string is taken from the B<AT_PLATFORM> value in the auxiliary vector (see B<getauxval>(3)).
fr: Est développé en une chaîne correspondant au type de processeur du système hôte (par exemple "x86_64"). Pour certaines architectures, le noyau Linux ne fournit pas de chaîne de caractère à l'éditeur de liens dynamique. La valeur de cette chaîne est issue de la valeur B<AT_PLATFORM> du vecteur auxiliaire (voir B<getauxval>(3)).

note: type: Plain text
en: List all dependencies and how they are resolved.
fr: Liste les dépendances et leurs résolutions.

note: type: Plain text
en: Verify that program is dynamically linked and this dynamic linker can handle it.
fr: Vérifie que le programme est lié dynamiquement et que l'éditeur de liens peut le traiter.

note: type: TP
en: B<--library-path PATH>
fr: B<--library-path CHEMIN>

note: type: Plain text
en: Use PATH instead of B<LD_LIBRARY_PATH> environment variable setting (see below).
fr: Utiliser CHEMIN à la place de la variable d'environnement B<LD_LIBRARY_PATH> (voir plus bas).

note: type: TP
en: B<--inhibit-rpath LIST>
fr: B<--inhibit-rpath LISTE>

note: type: Plain text
en: Ignore RPATH and RUNPATH information in object names in LIST.  This option is ignored if B<ld.so> is set-user-ID or set-group-ID.
fr: Ignorer les informations RPATH et RUNPATH dans les objets de la LISTE. Cette option est ignorée si B<ld.so> est I<setuid> ou I<setgid>.

note: type: TP
en: B<--audit LIST>
fr: B<--audit LISTE>

note: type: Plain text
en: Use objects named in LIST as auditors.
fr: Utilisez les objets nommés dans LISTE comme auditeurs.

note: type: SH
en: HARDWARE CAPABILITIES
fr: CAPACITÉS MATÉRIELLES

note: type: Plain text
en: Some libraries are compiled using hardware-specific instructions which do not exist on every CPU.  Such libraries should be installed in directories whose names define the required hardware capabilities, such as I</usr/lib/sse2/>.  The dynamic linker checks these directories against the hardware of the machine and selects the most suitable version of a given library.  Hardware capability directories can be cascaded to combine CPU features.  The list of supported hardware capability names depends on the CPU.  The following names are currently recognized:
fr: Certaines bibliothèques sont compilées en utilisant des instructions spécifiques au matériel qui n'existent pas sur tous les processeurs. Ces bibliothèques devraient être installées dans des répertoires dont les noms définissent les capacités matérielles nécessaires, comme I</usr/lib/sse2/>. L'éditeur de liens dynamique compare ces répertoires au matériel de la machine et sélectionne la version la mieux adaptée pour une bibliothèque donnée. Les répertoires de capacité matérielle peuvent être imbriqués pour combiner les caractéristiques du microprocesseur. La liste des noms de capacité matérielle pris en charge dépend du microprocesseur. Les noms suivants sont reconnus pour le moment.

note: type: TP
en: B<x86 (32-bit only)>
fr: B<x86 (32 bits seulement)>

note: type: SH
en: ENVIRONMENT
fr: ENVIRONNEMENT

note: type: Plain text
en: Among the more important environment variables are the following:
fr: Parmi les variables d'environnement importantes, on trouve :

note: type: Plain text
en: (glibc since 2.2.3)  Each shared library can inform the dynamic linker of the minimum kernel ABI version that it requires.  (This requirement is encoded in an ELF note section that is viewable via I<readelf\ -n> as a section labeled B<NT_GNU_ABI_TAG>.)  At run time, the dynamic linker determines the ABI version of the running kernel and will reject loading shared libraries that specify minimum ABI versions that exceed that ABI version.
fr: (glibc depuis 2.2.3) Toute bibliothèque partagée peut informer l'éditeur de liens dynamique de la version minimale requise de l'ABI noyau. (Cette exigence est enregistrée dans une section de note ELF, qui peut être lue avec I<readelf\ -n> sous le nom B<NT_GNU_ABI_TAG>.) Lors de l'exécution, l'éditeur de liens dynamique détermine la version d'ABI du noyau exécuté et rejettera le chargement de toute bibliothèque partagée qui spécifie une version minimale d'ABI supérieure.

note: type: Plain text
en: B<LD_ASSUME_KERNEL> can be used to cause the dynamic linker to assume that it is running on a system with a different kernel ABI version.  For example, the following command line causes the dynamic linker to assume it is running on Linux 2.2.5 when loading the shared libraries required by I<myprog>:
fr: B<LD_ASSUME_KERNEL> peut être utilisé afin que l'éditeur de liens dynamique considère qu'il est exécuté sur un système disposant d'une version différente de l'ABI noyau. Par exemple, la commande suivante permet de considérer la version 2.2.5 du noyau Linux lors du chargement des bibliothèques partagées utilisées par I<monprogamme>:

note: type: Plain text
en: $ B<LD_ASSUME_KERNEL=2.2.5 ./myprog>
fr: $ B<LD_ASSUME_KERNEL=2.2.5 ./monprogamme>

note: type: Plain text
en: On systems that provide multiple versions of a shared library (in different directories in the search path) that have different minimum kernel ABI version requirements, B<LD_ASSUME_KERNEL> can be used to select the version of the library that is used (dependent on the directory search order).  Historically, the most common use of the B<LD_ASSUME_KERNEL> feature was to manually select the older LinuxThreads POSIX threads implementation on systems that provided both LinuxThreads and NPTL (which latter was typically the default on such systems); see B<pthreads>(7).
fr: Lorsque plusieurs versions d'une même bibliothèque partagée (dans des répertoires différents du chemin de recherche) spécifient des versions minimales d'ABI noyau différents, B<LD_ASSUME_KERNEL> permet de sélectionner la version de la bibliothèque à utiliser (ce qui dépend de l'ordre de recherche des répertoires). Historiquement, B<LD_ASSUME_KERNEL> était surtout utilisé pour sélectionner l'ancienne mise en œuvre des threads POSIX par LinuxThreads sur les systèmes fournissant LinuxThreads et NPTL (ce dernier étant généralement activé par défaut); voir B<pthreads>(7).

note: type: Plain text
en: (glibc since 2.2)  Don't update the Global Offset Table (GOT) and Procedure Linkage Table (PLT)  when resolving a symbol.
fr: (glibc depuis 2.2) Ne pas mettre à jour les tables GOT (I<global offset table>) et PLT (I<procedure linkage table>) lors de la résolution d'un symbole.

note: type: Plain text
en: (libc5; glibc since 2.1.1)  If set to a nonempty string, causes the dynamic linker to resolve all symbols at program startup instead of deferring function call resolution to the point when they are first referenced.  This is useful when using a debugger.
fr: (libc5\ ; glibc depuis 2.1.1) Si la chaîne est non vide, l'éditeur de liens résoudra tous les symboles au démarrage du programme plutôt que repousser la résolution des noms de fonctions au moment où elles sont référencées en premier. Ceci est utile dans un débogueur.

note: type: Plain text
en: A colon-separated list of directories in which to search for ELF libraries at execution-time.  Similar to the B<PATH> environment variable.  Ignored in set-user-ID and set-group-ID programs.
fr: Comme la variable d'environnement B<PATH>, cette variable contient une liste de répertoires séparés par des deux-points. Les bibliothèques au format ELF sont recherchées à l'exécution dans ces répertoires. Ignorée dans les programmes I<setuid> ou I<setgid>.

note: type: Plain text
en: A list of additional, user-specified, ELF shared libraries to be loaded before all others.  The items of the list can be separated by spaces or colons.  This can be used to selectively override functions in other shared libraries.  The libraries are searched for using the rules given under DESCRIPTION.  For set-user-ID/set-group-ID ELF binaries, preload pathnames containing slashes are ignored, and libraries in the standard search directories are loaded only if the set-user-ID permission bit is enabled on the library file.
fr: Une liste de bibliothèques ELF spécifiques à l'utilisateur, à charger avant les autres bibliothèques. Les éléments de la liste peuvent être séparés par des espaces ou des deux points. Cela permet de surcharger sélectivement les fonctions des autres bibliothèques partagées. Les bibliothèques sont recherchées pour une utilisation des règles données en B<DESCRIPTION>. Pour les binaires ELF I<setuid> ou I<setgid>, les chemins de préchargement contenant des barres obliques sont ignorés, et les bibliothèques des répertoires standard ne sont chargées que si le bit de droit I<setuid> est activé sur le fichier de bibliothèque.

note: type: Plain text
en: (ELF only)  If set to a nonempty string, causes the program to list its dynamic library dependencies, as if run by B<ldd>(1), instead of running normally.
fr: (ELF seulement) Si la chaîne est non vide, le programme liste ses dépendances dynamiques comme s'il était lancé par B<ldd>(1), au lieu du lancement normal.

note: type: Plain text
en: Then there are lots of more or less obscure variables, many obsolete or only for internal use.
fr: Il existe de nombreuses autres variables plus ou moins obscures, certaines obsolètes, ou réservées pour un usage interne.

note: type: Plain text
en: (libc5)  Version of B<LD_LIBRARY_PATH> for a.out binaries only.  Old versions of ld-linux.so.1 also supported B<LD_ELF_LIBRARY_PATH>.
fr: (libc5) Version de B<LD_LIBRARY_PATH> pour les binaires a.out seulement. Les anciennes versions de ld-linux.so.1 supportent B<LD_ELF_LIBRARY_PATH>.

note: type: Plain text
en: (libc5)  Version of B<LD_PRELOAD> for a.out binaries only.  Old versions of ld-linux.so.1 also supported B<LD_ELF_PRELOAD>.
fr: (libc5) Version de B<LD_PRELOAD> pour les binaires a.out seulement. Les anciennes versions de ld-linux.so.1 supportent B<LD_ELF_PRELOAD>.

note: type: Plain text
en: (glibc since 2.4)  A colon-separated list of user-specified, ELF shared objects to be loaded before all others in a separate linker namespace (i.e., one that does not intrude upon the normal symbol bindings that would occur in the process).  These libraries can be used to audit the operation of the dynamic linker.  B<LD_AUDIT> is ignored for set-user-ID/set-group-ID binaries.
fr: (glibc depuis 2.4) Une liste d'objets partagés ELF spécifiés par l'utilisateur à charger avant tous les autres à l'intérieur d'un espace de nommage de l'éditeur de liens séparé (c'est-à-dire qu'il n'y aura pas d'interférence avec les liaisons sur les symboles normaux qui auront lieu pendant le processus). Ces bibliothèques peuvent être utilisées pour auditer les opérations effectuées par l'éditeur de liens dynamique. B<LD_AUDIT> est ignorée pour les exécutables I<setuid> ou I<setgid>.

note: type: Plain text
en: The dynamic linker will notify the audit libraries at so-called auditing checkpoints\(emfor example, loading a new library, resolving a symbol, or calling a symbol from another shared object\(emby calling an appropriate function within the audit library.  For details, see B<rtld-audit>(7).  The auditing interface is largely compatible with that provided on Solaris, as described in its I<Linker and Libraries Guide>, in the chapter I<Runtime Linker Auditing Interface>.
fr: L'éditeur de liens dynamique notifiera les bibliothèques d'audit à des endroits précis d'audit (appelés I<auditing checkpoints>) \(em par exemple au chargement d'une nouvelle bibliothèque, à la résolution d'un symbole, à l'appel d'un symbole depuis un autre objet partagé  \(em en appelant la fonction adéquate de la bibliothèque d'audit. Pour des informations plus détaillées, consultez B<rtld-audit>(7). L'interface d'audit est largement compatible avec celle disponible sur Solaris, décrite dans le I<Linker and Libraries Guide>, au chapitre I<Runtime Linker Auditing Interface>.

note: type: Plain text
en: (glibc since 2.1.95)  Do not update the GOT (global offset table) and PLT (procedure linkage table)  after resolving a symbol.
fr: (glibc depuis 2.1.95) Ne pas mettre à jour les tables GOT (I<global offset table>) et PLT (I<procedure linkage table>) après résolution d'un symbole.

note: type: Plain text
en: (glibc since 2.1)  Output verbose debugging information about the dynamic linker.  If set to B<all> prints all debugging information it has, if set to B<help> prints a help message about which categories can be specified in this environment variable.  Since glibc 2.3.4, B<LD_DEBUG> is ignored for set-user-ID/set-group-ID binaries.
fr: (glibc depuis 2.1) Afficher de nombreuses informations de débogage de l'éditeur dynamique. Si elle contient B<all>, afficher tous les messages d'information, si elle contient B<help>, afficher un message d'aide à propos des catégories de messages pour cette variable d'environnement. Depuis glibc 2.3.4, B<LD_DEBUG> n'est pas pris en compte pour les exécutables I<setuid> ou I<setgid>.

note: type: Plain text
en: (glibc since 2.1)  File in which B<LD_DEBUG> output should be written.  The default is standard error.  B<LD_DEBUG_OUTPUT> is ignored for set-user-ID/set-group-ID binaries.
fr: (glibc depuis 2.1) Fichier où la sortie de B<LD_DEBUG> devrait être envoyée. Par défaut, c'est la sortie d'erreur standard. B<LD_DEBUG_OUTPUT> est ignorée pour les exécutables I<setuid> ou I<setgid>.

note: type: Plain text
en: (glibc since 2.1.91)  Allow weak symbols to be overridden (reverting to old glibc behavior).  For security reasons, since glibc 2.3.4, B<LD_DYNAMIC_WEAK> is ignored for set-user-ID/set-group-ID binaries.
fr: (glibc depuis 2.1.91) Autorise la surcharge des symboles faibles (retour à l'ancien comportement). Pour des raisons de sécurité, depuis glibc 2.3.4, B<LD_DYNAMIC_WEAK> est ignorée pour les exécutables I<setuid> ou I<setgid>.

note: type: Plain text
en: (glibc since 2.1)  Mask for hardware capabilities.
fr: (glibc depuis 2.1)  Masque des capacités matérielles.

note: type: Plain text
en: (a.out only)(libc5)  Don't ignore the directory in the names of a.out libraries to be loaded.  Use of this option is strongly discouraged.
fr: (a.out seulement)(libc5) Ne pas ignorer le répertoire dans les noms de bibliothèques a.out. Cette option est très déconseillée.

note: type: Plain text
en: (a.out only)(libc5)  Suppress warnings about a.out libraries with incompatible minor version numbers.
fr: (a.out seulement)(libc5) Supprimer les avertissements à propos des bibliothèques a.out incompatibles avec les versions antérieures.

note: Only used if $ORIGIN can't be determined by normal means (from the origin path saved at load time, or from /proc/self/exe)? type: Plain text
en: (glibc since 2.1)  Path where the binary is found (for non-set-user-ID programs).  For security reasons, since glibc 2.4, B<LD_ORIGIN_PATH> is ignored for set-user-ID/set-group-ID binaries.
fr: (glibc depuis 2.1) Chemin où se trouve l'exécutable (pour des programmes non I<setuid>). Pour des raisons de sécurité, depuis glibc 2.4, B<LD_ORIGIN_PATH> est ignorée pour les exécutables I<setuid> ou I<setgid>.

note: type: Plain text
en: (glibc since 2.4)  Set to 0 to disable pointer guarding.  Any other value enables pointer guarding, which is also the default.  Pointer guarding is a security mechanism whereby some pointers to code stored in writable program memory (return addresses saved by B<setjmp>(3)  or function pointers used by various glibc internals) are mangled semi-randomly to make it more difficult for an attacker to hijack the pointers for use in the event of a buffer overrun or stack-smashing attack.
fr: (glibc depuis 2.4) Mettre à 0 pour supprimer la protection sur les pointeurs. Toute autre valeur active cette protection, ce qui est le comportement par défaut. La protection sur les pointeurs est un mécanisme de sécurité où certains pointeurs vers du code stocké dans la zone mémoire accessible en écriture (comme les adresses de retour conservées par B<setjmp>(3), ou des pointeurs de fonctions utilisés par diverses fonctions internes de glibc) sont modifiés semi-aléatoirement pour rendre plus difficile une utilisation malveillante par un intrus, qui utiliserait par exemple un dépassement de tampon ou de la pile.

note: type: Plain text
en: (glibc since 2.1)  Shared object to be profiled, specified either as a pathname or a soname.  Profiling output is written to the file whose name is: "I<$LD_PROFILE_OUTPUT>/I<$LD_PROFILE>.profile".
fr: (glibc depuis 2.1) Objet partagé à profiler, spécifié par un chemin ou par un nom d'objet partagé (I<soname>). Le résultat du profilage est écrit dans un fichier dont le nom est « I<$LD_PROFILE_OUTPUT>/I<$LD_PROFILE>.profile ».

note: type: Plain text
en: (glibc since 2.1)  Directory where B<LD_PROFILE> output should be written.  If this variable is not defined, or is defined as an empty string, then the default is I</var/tmp>.  B<LD_PROFILE_OUTPUT> is ignored for set-user-ID and set-group-ID programs, which always use I</var/profile>.
fr: (glibc depuis 2.1) Répertoire où sera écrit le résultat de B<LD_PROFILE>. Si cette variable n'est pas définie, ou si elle est définie à une valeur vide, le défaut est I</var/tmp>. B<LD_PROFILE_OUTPUT> est ignorée pour les exécutables I<setuid> ou I<setgid>, auquel cas le répertoire utilisé sera toujours I</var/profile>.

note: FIXME Document LD_TRACE_PRELINKING (e.g.: LD_TRACE_PRELINKING=libx1.so ./prog) Since glibc 2.3 Also enables DL_DEBUG_PRELINK type: Plain text
en: (glibc since 2.1)  Show auxiliary array passed up from the kernel.  For security reasons, since glibc 2.3.5, B<LD_SHOW_AUXV> is ignored for set-user-ID/set-group-ID binaries.
fr: (glibc depuis 2.1) Affiche les tableaux auxiliaires passés depuis le kernel. Pour des raisons de sécurité, depuis glibc 2.3.5, B<LD_SHOW_AUXV> est ignorée pour les exécutables I<setuid> ou I<setgid>.

note: http://sources.redhat.com/ml/libc-hacker/2003-11/msg00127.html Subject: [PATCH] Support LD_USE_LOAD_BIAS Jakub Jelinek type: Plain text
en: By default (i.e., if this variable is not defined)  executables and prelinked shared objects will honor base addresses of their dependent libraries and (nonprelinked) position-independent executables (PIEs)  and other shared objects will not honor them.  If B<LD_USE_LOAD_BIAS> is defined wit the value, both executables and PIEs will honor the base addresses.  If B<LD_USE_LOAD_BIAS> is defined with the value 0, neither executables nor PIEs will honor the base addresses.  This variable is ignored by set-user-ID and set-group-ID programs.
fr: Par défaut, c'est-à-dire si cette variable n'est pas définie, les exécutables et les objets partagés préchargés (I<prelink>) respectent l'adresse de base des bibliothèques dont ils dépendent, alors que les exécutables PIE (I<position-independent executables>) non préchargés et les autres objets partagés ne les respectent pas. Si B<LD_USE_LOAD_BIAS> est définie à une valeur non nulle, les exécutables et les PIE vont respecter les adresses de base. Si B<LD_USE_LOAD_BIAS> est définie à 0, ni les exécutables, ni les PIE ne respecteront les adresses de base. Cette variable est ignorée pour les exécutables I<setuid> ou I<setgid>.

note: type: Plain text
en: (glibc since 2.1)  If set to a nonempty string, output symbol versioning information about the program if the B<LD_TRACE_LOADED_OBJECTS> environment variable has been set.
fr: (glibc depuis 2.1) S'il s'agit d'une chaîne non vide, afficher les informations sur la version des objets sur le programme si la variable d'environnement B<LD_TRACE_LOADED_OBJECTS> a été définie.

note: type: Plain text
en: (ELF only)(glibc since 2.1.3)  If set to a nonempty string, warn about unresolved symbols.
fr: (ELF seulement)(glibc depuis 2.1.3) Si la chaîne est non vide, avertir si un symbole n'est pas résolu.

note: type: Plain text
en: (libc5)  I<argv>[0] to be used by B<ldd>(1)  when none is present.
fr: (libc5) I<argv>[0] à utiliser par B<ldd>(1) si aucun n'est présent.

note: type: SH
en: FILES
fr: FICHIERS

note: type: Plain text
en: a.out dynamic linker/loader
fr: Le chargeur et éditeur de liens dynamique a.out.

note: type: Plain text
en: ELF dynamic linker/loader
fr: Le chargeur et éditeur de liens dynamique ELF.

note: type: Plain text
en: File containing a compiled list of directories in which to search for libraries and an ordered list of candidate libraries.
fr: Fichier contenant la liste compilée des répertoires où se trouvent des bibliothèques, ainsi qu'une liste ordonnée de bibliothèques candidates.

note: type: Plain text
en: File containing a whitespace-separated list of ELF shared libraries to be loaded before the program.
fr: Fichier contenant une liste de bibliothèques ELF, séparées par des espaces, à charger avant de démarrer le programme.

note: type: TP
en: B<lib*.so*>
fr: I<lib*.so*>

note: type: Plain text
en: shared libraries
fr: Bibliothèques partagées.

note: type: Plain text
en: The B<ld.so> functionality is available for executables compiled using libc version 4.4.3 or greater.  ELF functionality is available since Linux 1.1.52 and libc5.
fr: Les fonctionnalités B<ld.so> sont disponibles pour les exécutables compilés à partir de la libc version 4.4.3 et ultérieures. Les fonctionnalités ELF sont disponibles depuis 1.1.52 et la libc5.

note: type: TH
en: 2012-05-10
fr: 10 mai 2012

note: type: Plain text
en: ldconfig - configure dynamic linker run-time bindings
fr: ldconfig - Configuration de l'éditeur de liens dynamique

note: type: Plain text
en: B</sbin/ldconfig> [ B<-nNvXV> ] [ B<-f\ conf> ] [ B<-C\ cache> ] [ B<-r\ root> ] I<directory>\ ...
fr: B</sbin/ldconfig> [ B<-nNvXV> ] [ B<-f\ configuration> ] [ B<-C\ cache> ] [ B<-r\ racine> ] I<répertoire>\ ...

note: type: Plain text
en: B</sbin/ldconfig> B<-l> [ B<-v> ] I<library>\ ...
fr: B</sbin/ldconfig> B<-l> [ B<-v> ] I<bibliothèque>\ ...

note: type: Plain text
en: B<ldconfig> creates the necessary links and cache to the most recent shared libraries found in the directories specified on the command line, in the file I</etc/ld.so.conf>, and in the trusted directories (I</lib> and I</usr/lib>).  The cache is used by the run-time linker, I<ld.so> or I<ld-linux.so>.  B<ldconfig> checks the header and filenames of the libraries it encounters when determining which versions should have their links updated.
fr: B<ldconfig> crée les liens nécessaires et met en cache les bibliothèques partagées les plus récentes trouvées dans les répertoires indiqués sur la ligne de commande, dans le fichier I</etc/ld.so.conf> et dans les répertoires sûrs (I</lib> et I</usr/lib>). Le cache est utilisé par le chargeur / éditeur de liens, I<ld.so> ou I<ld-linux.so>. B<ldconfig> vérifie les en-têtes et noms des fichiers des bibliothèques qu'il trouve pour déterminer les versions et mettre à jour les liens. B<ldconfig> ignore les liens symboliques lorsqu'il analyse les bibliothèques.

note: The following sentence looks suspect (perhaps historical cruft) -- MTK, Jul 2005 Therefore, when making dynamic libraries, it is wise to explicitly link against libc (use \-lc). type: Plain text
en: B<ldconfig> will attempt to deduce the type of ELF libs (i.e., libc5 or libc6/glibc)  based on what C libs, if any, the library was linked against.
fr: B<ldconfig> essaye de déduire le type bibliothèque ELF (libc5 ou libc6/glibc) en se basant sur la bibliothèque\ C utilisée pour les liens de la bibliothèque.

note: type: Plain text
en: Some existing libs do not contain enough information to allow the deduction of their type.  Therefore, the I</etc/ld.so.conf> file format allows the specification of an expected type.  This is used I<only> for those ELF libs which we can not work out.  The format is "dirname=TYPE", where TYPE can be libc4, libc5, or libc6.  (This syntax also works on the command line.)  Spaces are I<not> allowed.  Also see the B<-p> option.  B<ldconfig> should normally be run by the superuser as it may require write permission on some root owned directories and files.
fr: Certaines bibliothèques existantes ne contiennent pas assez d'informations pour déduire leur type. Ainsi, le format du fichier I</etc/ld.so.conf> permet d'indiquer le type attendu. Cela ne doit servir B<que> pour les bibliothèques ELF qui ne fonctionnent pas sinon. Le format est « répertoire=TYPE », où TYPE peut être libc4, libc5 ou libc6. (Cette syntaxe fonctionne aussi sur la ligne de commande). Les espaces ne sont B<pas> autorisés. Consultez aussi l'option B<-p>. B<ldconfig> devrait normalement être exécuté par le superutilisateur, car des permissions en écriture sont nécessaires sur des répertoires et des fichiers qui lui appartiennent.

note: type: Plain text
en: Verbose mode.  Print current version number, the name of each directory as it is scanned, and any links that are created.  Overrides quiet mode.
fr: Mode volubile. Affiche le numéro de version actuelle, le nom de chaque répertoire au fur et à mesure du parcours, et les liens qui sont créés. Peut surcharger le mode silencieux.

note: type: Plain text
en: Only process directories specified on the command line.  Don't process the trusted directories (I</lib> and I</usr/lib>)  nor those specified in I</etc/ld.so.conf>.  Implies B<-N>.
fr: Ne traiter que les répertoires indiqués sur la ligne de commande. Ne pas s'occuper des répertoires sûrs (I</lib> et I</usr/lib>) ni de ceux indiqués dans I</etc/ld.so.conf>. Implique l'option B<-N>.

note: type: Plain text
en: Don't rebuild the cache.  Unless B<-X> is also specified, links are still updated.
fr: Ne pas reconstruire le cache. Si l'option B<-X> n'est pas indiquée, les liens sont quand même mis à jour.

note: type: Plain text
en: Don't update links.  Unless B<-N> is also specified, the cache is still rebuilt.
fr: Ne pas mettre à jour les liens. Si l'option B<-N> n'est pas indiquée, le cache est quand même reconstruit.

note: type: TP
en: B<-f conf>
fr: B<-f configuration>

note: type: Plain text
en: Use B<conf> instead of I</etc/ld.so.conf>.
fr: Utiliser le fichier de B<configuration> indiqué plutôt que I</etc/ld.so.conf>.

note: type: Plain text
en: Use B<cache> instead of I</etc/ld.so.cache>.
fr: Utiliser le B<cache> indiqué plutôt que I</etc/ld.so.cache>.

note: type: TP
en: B<-r root>
fr: B<-r racine>

note: type: Plain text
en: Change to and use I<root> as the root directory.
fr: Se déplacer vers, et utiliser le répertoire I<racine> indiqué.

note: type: Plain text
en: Library mode.  Manually link individual libraries.  Intended for use by experts only.
fr: Mode bibliothèque. Lier manuellement les bibliothèques individuelles. Destiné seulement aux experts.

note: type: Plain text
en: Print the lists of directories and candidate libraries stored in the current cache.
fr: Afficher la liste des répertoires et des bibliothèques potentielles enregistrés dans le cache actuel.

note: type: Plain text
en: run-time linker/loader
fr: chargeur/éditeur de liens dynamiques

note: type: Plain text
en: File containing a list of colon, space, tab, newline, or comma-separated directories in which to search for libraries.
fr: Fichier contenant une liste de répertoires où chercher les bibliothèques, séparés par des deux-points, espaces, tabulations, nouvelles lignes ou des virgules.

note: type: Plain text
en: File containing an ordered list of libraries found in the directories specified in I</etc/ld.so.conf>, as well as those found in I</lib> and I</usr/lib>.
fr: Fichier contenant une liste ordonnée des bibliothèques trouvées dans les répertoires indiqués dans I</etc/ld.so.conf>, ainsi que celles trouvées dans I</lib> et I</usr/lib>.

note: type: TH
en: 2012-07-16
fr: 16 juillet 2012

note: type: Plain text
en: ldd - print shared library dependencies
fr: ldd - Afficher les bibliothèques partagées nécessaires

note: type: Plain text
en: B<ldd> [OPTION]... FILE...
fr: B<ldd> [OPTION]... FICHIER...

note: type: Plain text
en: B<ldd> prints the shared libraries required by each program or shared library specified on the command line.
fr: B<ldd> affiche la liste des bibliothèques partagées nécessaires pour chaque programme ou bibliothèque passés sur la ligne de commande.

note: type: SS
en: Security
fr: Sécurité

note: Mainline glibc's ldd allows this possibility (the line try_trace "$file" in glibc 2.15, for example), but many distro versions of ldd seem to remove that code path from the script. type: Plain text
en: In the usual case, B<ldd> invokes the standard dynamic linker (see B<ld.so>(8))  with the B<LD_TRACE_LOADED_OBJECTS> environment variable set to 1, which causes the linker to display the library dependencies.  Be aware, however, that in some circumstances, some versions of B<ldd> may attempt to obtain the dependency information by directly executing the program.  Thus, you should I<never> employ B<ldd> on an untrusted executable, since this may result in the execution of arbitrary code.  A safer alternative when dealing with untrusted executables is:
fr: Normalement, B<ldd> appelle l'éditeur de liens standard (consultez B<ld.so>(8)) avec la variable d'environnement B<LD_TRACE_LOADED_OBJECTS> définie à 1, ce qui force l'éditeur de liens à afficher les dépendances de bibliothèques. Soyez conscient, tout de même, que dans certaines circonstances, certaines versions de B<ldd> risquent d'essayer d'obtenir les renseignements de dépendances en exécutant directement le programme. Par conséquent, vous ne devriez B<jamais> utiliser B<ldd> sur du code exécutable non sûr, car cela pourrait avoir pour conséquence l'exécution de code arbitraire. Un autre moyen de traiter les exécutables non sûr est :

note: type: Plain text
en:     $ objdump -p /path/to/program | grep NEEDED
fr:     $ objdump -p /chemin/vers/le/programme | grep NEEDED

note: type: Plain text
en: Print the version number of B<ldd>.
fr: Afficher le numéro de version de B<ldd>.

note: type: Plain text
en: Print all information, including, for example, symbol versioning information.
fr: Afficher toutes les informations, y compris les versions des symboles.

note: type: Plain text
en: Print unused direct dependencies.  (Since glibc 2.3.4.)
fr: Afficher les dépendances directes inutilisées (depuis la glibc\ 2.3.4).

note: type: Plain text
en: Perform relocations and report any missing objects (ELF only).
fr: Réaliser les déplacements et indiquer les objets manquants (ELF seulement).

note: type: Plain text
en: Perform relocations for both data objects and functions, and report any missing objects or functions (ELF only).
fr: Réaliser les déplacements pour les objets donnés et les fonctions, et indiquer les objets ou fonctions manquants (ELF seulement).

note: type: Plain text
en: Usage information.
fr: Aide.

note: type: Plain text
en: The standard version of B<ldd> comes with glibc2.  Libc5 came with an older version, still present on some systems.  The long options are not supported by the libc5 version.  On the other hand, the glibc2 version does not support B<-V> and only has the equivalent B<--version>.
fr: La version standard de B<ldd> est livrée avec la glibc2. La libc5 fournissait une ancienne version, toujours présente sur certains systèmes. Les options longues ne sont pas supportées par la version de la libc5. En revanche, celle de la glibc2 ne supporte pas B<-V> et a seulement l'équivalent B<--version>.

note: type: Plain text
en: The libc5 version of this program will use the name of a library given on the command line as-is when it contains a \(aq/\(aq; otherwise it searches for the library in the standard locations.  To run it on a shared library in the current directory, prefix the name with "./".
fr: La version libc5 utilise le nom de la bibliothèque donnée sur la ligne de commande tel quel s'il contient un «\ /\ »\ ; sinon elle cherche la bibliothèque aux emplacements standard. Pour l'utiliser sur une bibliothèque dans le répertoire courant, préfixez son nom avec «\ ./\ ».

note: type: Plain text
en: B<ldd> does not work on a.out shared libraries.
fr: B<ldd> ne fonctionne pas avec les bibliothèques partagées a.out.

note: .SH AUTHOR David Engel. Roland McGrath and Ulrich Drepper. type: Plain text
en: B<ldd> does not work with some extremely old a.out programs which were built before B<ldd> support was added to the compiler releases.  If you use B<ldd> on one of these programs, the program will attempt to run with I<argc> = 0 and the results will be unpredictable.
fr: B<ldd> ne fonctionne pas avec certains programmes a.out très anciens qui ont été compilés avant que le support de B<ldd> ne soit ajouté dans le compilateur. Si vous utilisez B<ldd> sur l'un de ces programmes, il sera lancé avec I<argc> = 0 et les résultats seront imprévisibles.

note: type: TH
en: 2012-07-07
fr: 7 juillet 2012

note: type: Plain text
en: rtld-audit - auditing API for the dynamic linker
fr: rtld-audit - API d'audit pour l'éditeur de liens dynamique

note: type: Plain text
en: B<#define _GNU_SOURCE> /* See feature_test_macros(7) */
fr: B<#define _GNU_SOURCE> /* Consultez feature_test_macros(7) */

note: type: Plain text
en: The GNU dynamic linker (run-time linker)  provides an auditing API that allows an application to be notified when various dynamic linking events occur.  This API is very similar to the auditing interface provided by the Solaris run-time linker.  The necessary constants and prototypes are defined by including I<E<lt>link.hE<gt>>.
fr: L'éditeur de liens dynamique GNU (l'éditeur de liens à l'exécution) fournit une API d'audit qui permet à une application d'être notifiée quand différents événements liés à l'édition de liens surviennent. Cette API est très similaire à l'interface d'audit fournie par l'éditeur de liens Solaris. Les constantes et prototypes nécessaires sont définis en incluant I<E<lt>link.hE<gt>>.

note: type: Plain text
en: To use this interface, the programmer creates a shared library that implements a standard set of function names.  Not all of the functions need to be implemented: in most cases, if the programmer is not interested in a particular class of auditing event, then no implementation needs to be provided for the corresponding auditing function.
fr: Pour utiliser cette interface, le programmeur crée une bibliothèque partagée qui implémente un ensemble standard de noms de fonctions. Toutes les fonctions n'ont pas à être implémentées : dans la plupart des cas, si le programmeur n'est pas intéressé dans une certaine classe d'événements d'audit, alors aucune implémentation n'a à être fournie pour la fonction d'audit correspondante.

note: type: Plain text
en: To employ the auditing interface, the environment variable B<LD_AUDIT> must be defined to contain a colon-separated list of shared libraries, each of which can implement (parts of) the auditing API.  When an auditable event occurs, the corresponding function is invoked in each library, in the order that the libraries are listed.
fr: Pour utiliser l'interface d'audit, la variable d'environnement B<LD_AUDIT> doit être définie avec une liste de bibliothèques partagées, séparées par des « deux-points », qui peuvent implémenter l'API (ou une partie) d'audit. Quand un événement pouvant être surveillé survient, la fonction correspondante est appelée dans chaque bibliothèque, dans l'ordre où sont listées les bibliothèques.

note: type: Plain text
en: This is the only function that I<must> be defined by an auditing library: it performs the initial handshake between the dynamic linker and the auditing library.  When invoking this function, the dynamic linker passes, in I<version>, the highest version of the auditing interface that the linker supports.  If necessary, the auditing library can check that this version is sufficient for its requirements.
fr: Il s'agit de la seule fonction qui I<doit> être définie par une bibliothèque d'audit : elle effectue la présentation initiale entre l'éditeur de liens et la bibliothèque d'audit. Lorsque cette fonction est appelée, l'éditeur de liens passe, dans I<version>, la version la plus importante de l'interface d'audit qui soit prise en charge par l'éditeur de liens. Si nécessaire, la bibliothèque d'audit peut vérifier que cette version suffit à ses besoins.

note: type: Plain text
en: As its function result, this function should return the version of the auditing interface that this auditing library expects to use (returning I<version> is acceptable).  If the returned value is 0, or a version that is greater than that supported by the dynamic linker, then the audit library is ignored.
fr: En retour, cette fonction doit renvoyer la version de l'interface d'audit que cette bibliothèque d'audit va utiliser (renvoyer I<version> est permis). Si la valeur de retour est 0 ou une version supérieure à celle prise en charge par l'éditeur de liens, alors la bibliothèque d'audit est ignorée.

note: type: Plain text
en: The dynamic linker invokes this function to inform the auditing library that it is about to search for a shared object.  The I<name> argument is the filename or pathname that is to be searched for.  I<cookie> identifies the shared object that initiated the search.  I<flag> is set to one of the following values:
fr: L'éditeur de liens appelle cette fonction pour informer la bibliothèque d'audit qu'il va se mettre à la recherche d'un objet partagé. Le paramètre I<name> est le nom de fichier ou le chemin dans lequel s'effectue la recherche. I<cookie> identifie l'objet partagé qui a déclenché la recherche. I<flag> est l'une des valeurs suivantes :

note: type: Plain text
en: This is the original name that is being searched for.  Typically, this name comes from an ELF B<DT_NEEDED> entry, or is the I<filename> argument given to B<dlopen>(3).
fr: Il s'agit du nom de départ de la recherche. Généralement ce nom provient d'une entrée ELF B<DT_NEEDED> ou est le paramètre I<filename> fourni à B<dlopen>(3).

note: type: Plain text
en: I<name> was created using a directory specified in B<LD_LIBRARY_PATH>.
fr: I<name> a été créé en utilisant un répertoire indiqué dans B<LD_LIBRARY_PATH>.

note: type: Plain text
en: I<name> was created using a directory specified in an ELF B<DT_RPATH> or B<DT_RUNPATH> list.
fr: I<name> a été créé en utilisant un répertoire indiqué dans une liste ELF B<DT_RPATH> ou B<DT_RUNPATH>.

note: type: Plain text
en: I<name> was found via the B<ldconfig>(8)  cache (I</etc/ld.so.cache>).
fr: I<name> a été trouvé par le cache B<ldconfig>(8) (I</etc/ld.so.cache>).

note: type: Plain text
en: I<name> was found via a search of one of the default directories.
fr: I<name> a été trouvé par une recherche dans un des répertoires par défaut.

note: type: Plain text
en: I<name> is specific to a secure object (unused on Linux).
fr: I<name> est spécifique à un objet sûr (pas utilisé sous Linux).

note: type: Plain text
en: As its function result, B<la_objsearch>()  returns the pathname that the dynamic linker should use for further processing.  If NULL is returned, then this pathname is ignored for further processing.  If this audit library simply intends to monitor search paths, then I<name> should be returned.
fr: B<la_objsearch>() renvoie comme valeur de retour le chemin que l'éditeur de liens devrait utiliser pour les opérations suivantes. Si NULL est renvoyé, alors le chemin est ignoré par la suite. Les bibliothèques qui ne cherche qu'à observer les chemins de recherche devraient renvoyer I<name>.

note: type: Plain text
en: The dynamic linker calls this function to inform the auditing library that link-map activity is occurring.  I<cookie> identifies the object at the head of the link map.  When the dynamic linker invokes this function, I<flag> is set to one of the following values:
fr: L'éditeur de liens appelle cette fonction pour informer la bibliothèque d'audit d'activités sur la table des liens. I<cookie> identifie l'objet à la tête de la table. Quand l'éditeur de liens appelle cette fonction, I<flag> vaut l'une des valeurs suivantes :

note: type: Plain text
en: New objects are being added to the link map.
fr: De nouveaux objets sont ajoutés à la table.

note: type: Plain text
en: Objects are being removed from the link map.
fr: Des objets sont retirés d ela table.

note: type: Plain text
en: Link-map activity has been completed: the map is once again consistent.
fr: L'activité sur la table est terminée : la table est de nouveau cohérente.

note: type: Plain text
en: The dynamic linker calls this function when a new shared object is loaded.  The I<map> argument is a pointer to a link-map structure that describes the object.  The I<lmid> field has one of the following values
fr: L'éditeur de liens appelle cette fonction quand un nouvel objet partagé est chargé. Le paramètre I<map> est un pointeur vers la structure d'une table de liens qui décrit l'objet. Le champ I<lmid> prend une des valeurs suivantes :

note: type: Plain text
en: Link map is part of the initial namespace.
fr: La table fait partie de l'espace de noms de départ.

note: type: Plain text
en: Link map is part of a new namespace requested via B<dlmopen>(3).
fr: La table fait partie d'un nouvel espace de noms demandé avec B<dlmopen>(3).

note: type: Plain text
en: I<cookie> is a pointer to an identifier for this object.  The identifier is provided to later calls to functions in the auditing library in order to identify this object.  This identifier is initialized to point to object's link map, but the audit library can change the identifier to some other value that it may prefer to use to identify the object.
fr: I<cookie> est un pointeur vers un identifiant pour un objet. L'identifiant est fourni aux appels suivants des fonctions de la bibliothèque d'audit afin d'identifier l'objet. L'identifiant est initialisé pour pointer vers la table de l'objet, mais la bibliothèque d'audit peut changer l'identifiant pour une autre valeur qu'elle préférerait utiliser pour identifier l'objet.

note: type: Plain text
en: As its return value, B<la_objopen>()  returns a bit mask created by ORing zero or more of the following constants, which allow the auditing library to select the objects to be monitored by B<la_symbind*>():
fr: B<la_objopen>() renvoie comme valeur de retour un masque de bits créé en combinant zéro ou plusieurs constantes avec un OU binaire, ce qui permet à la bibliothèque d'audit de sélectionner les objets à surveiller avec les fonctions B<la_symbind*>() :

note: type: Plain text
en: Audit symbol bindings to this object.
fr: Surveiller les associations de symboles à cet objet.

note: type: Plain text
en: Audit symbol bindings from this object.
fr: Surveiller les associations de symboles provenant de cet objet.

note: type: Plain text
en: A return value of 0 from B<la_objopen>()  indicates that no symbol bindings should be audited for this object.
fr: Une valeur de retour de 0 pour B<la_objopen>() indique qu'aucune association de symbole n'est à surveiller pour cet objet.

note: type: Plain text
en: The dynamic linker invokes this function after any finalization code for the object has been executed, before the object is unloaded.  The I<cookie> argument is the identifier obtained from a previous invocation of B<la_objopen>().
fr: L'éditeur de liens appelle cette fonction après l'exécution du code de finalisation pour l'objet (s'il y en a), et avant que l'objet soit déchargé. Le paramètre I<cookie> est l'identifiant obtenu par l'appel précédent à B<la_objopen>().

note: type: Plain text
en: In the current implementation, the value returned by B<la_objclose>()  is ignored.
fr: Dans l'implémentation actuelle, la valeur renvoyée par B<la_objclose>() est ignorée.

note: type: Plain text
en: The dynamic linker invokes this function after all shared objects have been loaded, before control is passed to the application (i.e., before calling I<main>()).  Note that I<main>()  may still later dynamically load objects using B<dlopen>(3).
fr: L'éditeur de liens appelle cette fonction après que tous les objets partagés ont été chargés, avant que le contrôle soit donné à l'application (c'est-à-dire avant l'appel à I<main>()). Notez que I<main>() peut encore charger des objets dynamiquement en utilisant B<dlopen>(3).

note: type: Plain text
en: The dynamic linker invokes one of these functions when a symbol binding occurs between two shared objects that have been marked for auditing notification by B<la_objopen>().  The B<la_symbind32>()  function is employed on 32-bit platforms; the B<la_symbind64>()  function is employed on 64-bit platforms.
fr: L'éditeur de liens appelle une de ces fonctions quand une association de symbole survient entre deux objets partagés qui ont été marqués comme étant surveillés par B<la_objopen>(). La fonction B<la_symbind32>() est utilisée pour les plate-formes 32 bits ; la fonction B<la_symbind64>() est utilisée pour les plate-formes 64 bits.

note: type: Plain text
en: The I<sym> argument is a pointer to a structure that provides information about the symbol being bound.  The structure definition is shown in I<E<lt>elf.hE<gt>>.  Among the fields of this structure, I<st_value> indicates the address to which the symbol is bound.
fr: Le paramètre I<sym> est un pointeur vers une structure qui fournit des informations sur le symbole en cours d'association. La définition de la structure se trouve dans I<E<lt>elf.hE<gt>>. Parmi les champs de la structure, I<st_value> indique l'adresse à laquelle le symbole est associé.

note: type: Plain text
en: The I<ndx> argument gives the index of the symbol in the symbol table of the bound shared object.
fr: Le paramètre I<ndx> fournit l'index du symbole dans la table des symboles de l'objet partagé associé.

note: type: Plain text
en: The I<refcook> argument identifies the shared object that is making the symbol reference; this is the same identifier that is provided to the B<la_objopen>()  function that returned B<LA_FLG_BINDFROM>.  The I<defcook> argument identifies the shared object that defines the referenced symbol; this is the same identifier that is provided to the B<la_objopen>()  function that returned B<LA_FLG_BINDTO>.
fr: Le paramètre I<refcook> identifie l'objet partagé qui crée la référence du symbole ; il s'agit du même identifiant fourni à la fonction B<la_objopen>() qui a renvoyé B<LA_FLG_BINDFROM>. Le paramètre I<defcook> identifie l'objet partagé qui défini le symbole référencé ; il s'agit du même identifiant fourni à la fonction B<la_objopen>() qui a renvoyé B<LA_FLG_BINDTO>.

note: type: Plain text
en: The I<symname> argument points a string containing the name of the symbol.
fr: Le paramètre I<symname> pointe vers une chaîne contenant le nom du symbole.

note: LA_SYMB_STRUCTCALL appears to be unused type: Plain text
en: The I<flags> argument is a bit mask that both provides information about the symbol and can be used to modify further auditing of this PLT (Procedure Linkage Table) entry.  The dynamic linker may supply the following bit values in this argument:
fr: Le paramètre I<flags> est un masque de bits qui peut à la fois fournir des informations sur le symbole et être utilisé pour modifier encore plus la surveillance de cette entrée de la PLT (Procedure Linkage Table). L'éditeur de liens dynamique peut fournir les bits suivants dans ce paramètre :

note: type: Plain text
en: The binding resulted from a call to B<dlsym>(3).
fr: L'association provient d'un appelle à B<dlsym>(3).

note: type: Plain text
en: A previous B<la_symbind*>()  call returned an alternate value for this symbol.
fr: Un appel précédent à B<la_symbind*>() a renvoyé une autre valeur pour ce symbole.

note: pltenter/pltexit are called for non-dynamically loaded libraries, but don't seem to be called for dynamically loaded libs? Is this the same on Solaris? type: Plain text
en: By default, if the auditing library implements B<la_pltenter>()  and B<la_pltexit>()  functions (see below), then these functions are invoked, after B<la_symbind>(), for PLT entries, each time the symbol is referenced.  The following flags can be ORed into I<*flags> to change this default behavior:
fr: Par défaut, si la bibliothèque d'audit implémente les fonctions B<la_pltenter>() et B<la_pltexit>() (voir ci-dessous), alors ces fonctions sont appelées, après B<la_symbind>(), pour les entrées de la PLT, à chaque fois que le symbole est référencé. Les drapeaux suivants peuvent être fournis en les combinant avec un OU binaire dans I<*flags> pour modifier ce comportement par défaut :

note: type: Plain text
en: Don't call B<la_pltenter>()  for this symbol.
fr: Ne pas appeler B<la_pltenter>() pour ce symbole.

note: type: Plain text
en: Don't call B<la_pltexit>()  for this symbol.
fr: Ne pas appeler B<la_pltexit>() pour ce symbole.

note: type: Plain text
en: The return value of B<la_symbind32>()  and B<la_symbind64>()  is the address to which control should be passed after the function returns.  If the auditing library is simply monitoring symbol bindings, then it should return I<sym-E<gt>st_value>.  A different value may be returned if the library wishes to direct control to an alternate location.
fr: La valeur de retour de B<la_symbind32>() et B<la_symbind64>() est l'adresse à laquelle le contrôle doit être donné après que la fonction se termine. Si la bibliothèque d'audit ne fait qu'observer les associations de symboles, elle devrait renvoyer I<sym-E<gt>st_value>. Une valeur différente peut être renvoyée si la bibliothèque souhaite rediriger le contrôle à un autre endroit.

note: type: Plain text
en: The precise name and argument types for this function depend on the hardware platform.  (The appropriate definition is supplied by I<E<lt>link.hE<gt>>.)  Here is the definition for x86-32:
fr: Le nom et les types des paramètres de cette fonction dépendent de la plate-forme matérielle. (la définition appropriée est fournie par I<E<lt>link.hE<gt>>.) Voici la définition pour la plate-forme x86-32 :

note: type: Plain text
en: This function is invoked just before a PLT entry is called, between two shared objects that have been marked for binding notification.
fr: Cette fonction est appelée juste avant l'appel d'une entrée de la PLT, entre deux objets partagés ayant été marqués pour la notification des associations.

note: type: Plain text
en: The I<sym>, I<ndx>, I<refcook>, I<defcook>, and I<symname> are as for B<la_symbind*>().
fr: Les paramètres I<sym>, I<ndx>, I<refcook>, I<defcook> et I<symname> sont comme pour B<la_symbind*>().

note: type: Plain text
en: The I<regs> argument points to a structure (defined in I<E<lt>link.hE<gt>>)  containing the values of registers to be used for the call to this PLT entry.
fr: Le paramètre I<regs> pointe vers une structure (définie dans I<E<lt>link.hE<gt>>) qui contient les valeurs des registres à utiliser pour l'appel à cette entrée de la PLT.

note: type: Plain text
en: The I<flags> argument points to a bit mask that conveys information about, and can be used to modify subsequent auditing of, this PLT entry, as for B<la_symbind*>().
fr: Le paramètre I<flags> pointe vers une masque de bits qui, comme pour B<la_symbind*>(), fournit des informations pour cette entrée de la PLT et peut être utilisé pour modifier la façon dont elle sera surveillée ultérieurement.

note: FIXME is the following correct? type: Plain text
en: The I<framesizep> argument points to a I<long\ int> buffer that can be used to explicitly set the frame size used for the call to this PLT entry.  If different B<la_pltenter>()  invocations for this symbol return different values, then the maximum returned value is used.  The B<la_pltenter>()  function is called only if this buffer is explicitly set to a suitable value.
fr: Le paramètre I<framesizep> pointe vers un I<long\ int> qui peut être utilisé pour définir explicitement la taille de la trame utilisée pour l'appel à cette entrée de la PLT. Si différents appels à B<la_pltenter>() pour ce symbole renvoient différentes valeurs, alors la valeur maximale renvoyée est utilisée. La fonction B<la_pltenter>() n'est appelée que si ce pointeur est explicitement définit avec une valeur convenable.

note: type: Plain text
en: The return value of B<la_pltenter>()  is as for B<la_symbind*>().
fr: La valeur de retour de B<la_pltenter>() est comme pour B<la_symbind*>().

note: type: Plain text
en: This function is called when a PLT entry, made between two shared objects that have been marked for binding notification, returns.  The function is called just before control returns to the caller of the PLT entry.
fr: Cette fonction est appelée quand une entrée de la PLT, créée entre deux objets partagés ayant été marqués pour la notification des associations, se termine. La fonction est appelée juste avant que le contrôle soit rendu à l'appelant de l'entrée de la PLT.

note: type: Plain text
en: The I<inregs> argument points to a structure (defined in I<E<lt>link.hE<gt>>)  containing the values of registers used for the call to this PLT entry.  The I<outregs> argument points to a structure (defined in I<E<lt>link.hE<gt>>)  containing return values for the call to this PLT entry.  These values can be modified by the caller, and the changes will be visible to the caller of the PLT entry.
fr: Le paramètre I<inregs> pointe vers une structure (définie dans I<E<lt>link.hE<gt>>) qui contient les valeurs des registres utilisés pour l'appel à cette entrée de la PLT. Le paramètre I<outregs> pointe vers une structure (définie dans I<E<lt>link.hE<gt>>) qui contient les valeurs de retour de l'appel à cette entrée de la PLT. Ces valeurs peuvent être modifiées par l'appelant et les modifications seront visibles pour l'appelant de l'entrée de la PLT.

note: This differs from Solaris, where an audit library that monitors symbol binding should return the value of the 'retval' argument (not provided by GNU, but equivalent to returning outregs->lrv_eax on (say) x86-32). type: Plain text
en: In the current GNU implementation, the return value of B<la_pltexit>()  is ignored.
fr: Dans l'implémentation GNU actuelle, la valeur de retour de B<la_pltexit>() est ignorée.

note: type: Plain text
en: This API is nonstandard, but very similar to the Solaris API, described in the Solaris I<Linker and Libraries Guide>, in the chapter I<Runtime Linker Auditing Interface>.
fr: Cette API n'est pas standard, mais est très proche de l'API Solaris, décrite dans le guide Solaris I<Linker and Libraries Guide>, au chapitre I<Runtime Linker Auditing Interface>.

note: type: Plain text
en: Note the following differences from the Solaris dynamic linker auditing API:
fr: Notez les différences suivantes avec l'API d'audit de l'éditeur de liens Solaris :

note: type: Plain text
en: The Solaris B<la_objfilter>()  interface is not supported by the GNU implementation.
fr: L'interface Solaris B<la_objfilter>() n'est pas prise en charge par l'implémentation GNU.

note: type: Plain text
en: The Solaris B<la_symbind32>()  and B<la_pltexit>()  functions do not provide a I<symname> argument.
fr: Les fonctions Solaris B<la_symbind32>() et B<la_pltexit>() ne fournissent pas de paramètre I<symname>.

note: type: Plain text
en: The Solaris B<la_pltexit>()  function does not provide I<inregs> and I<outregs> arguments (but does provide a I<retval> argument with the function return value).
fr: La fonction Solaris B<la_pltexit>() ne fournit pas de paramètre I<inregs> ou I<outregs> (mais fournit une paramètre I<retval> avec la valeur de retour de la fonction).

note: FIXME Specifying multiple audit libraries doesn't work on GNU. My simple tests on Solaris work okay, but not on Linux -- mtk, Jan 2009 glibc bug filed: http://sourceware.org/bugzilla/show_bug.cgi?id=9733 Reportedly, this is fixed on 16 Mar 2009 (i.e., for glibc 2.10) type: Plain text
en: In glibc versions up to and include 2.9, specifying more than one audit library in B<LD_AUDIT> results in a run-time crash.  This is reportedly fixed in glibc 2.10.
fr: Dans les versions de la glibc jusqu'à la version 2.9 (inclue), fournit plus d'une bibliothèque d'audit dans B<LD_AUDIT> provoquait un crash à l'exécution. Cela a été corrigé dans la version 2.10.

note: type: TH
en: 2013-02-10
fr: 10 février 2013

note: type: Plain text
en: sln - create symbolic links
fr: sln - Créer des liens symboliques

note: type: Plain text
en: B<sln>I< filelist>
fr: B<sln> I<liste_de_fichiers>

note: type: Plain text
en: The B<sln> program creates symbolic links.  Unlike the B<ln>(1)  program, it is statically linked.  This means that if for some reason the dynamic linker is not working, B<sln> can be used to make symbolic links to dynamic libraries.
fr: Le programme B<sln> crée des liens symboliques. Contrairement au programme B<ln>(1), ce programme est statique. B<sln> est ainsi utilisable même lorsque l'éditeur de lien dynamique n'est pas fonctionnel.

note: type: Plain text
en: The command line has two forms.  In the first form, it creates I<dest> as a new symbolic link to I<source>.
fr: La ligne de commandes a deux formes. Dans la première forme, I<dest> est créé comme un nouveau lien symbolique vers I<source>.

note: type: Plain text
en: In the second form, I<filelist> is a list of space-separated pathname pairs, and the effect is as if B<sln> was executed once for each line of the file, with the two pathnames as the arguments.
fr: Dans la seconde forme, I<liste_de_fichiers> est une liste de paires de noms de chemin séparés par un espace, et a un effet similaire à exécuter B<sln> pour chaque ligne du fichier, avec les deux noms de chemin comme arguments.

note: type: Plain text
en: The B<sln> program supports no command-line options.
fr: Le programme B<sln> n'accepte pas d'option en ligne de commande.
