symboles de débogage gcc (- drapeau g) vs option de linker-rdynamic

selon les docs:

Ceci indique au linker d'ajouter tous les symboles, pas seulement ceux utilisés, à la table de symboles dynamiques.

ce ne sont pas des symboles de débogage, ce sont des symboles de linker dynamique. Ceux-ci ne sont pas enlevés par strip puisqu'il briserait (dans la plupart des cas) l'exécutable - ils sont utilisés par le linker d'exécution pour faire l'étape finale du lien de votre exécutable.

Exemple:

$ cat t.c
void foo() {}
int main() { foo(); return 0; }

Compiler et lier sans -rdynamic (et pas des optimisations, évidemment)

$ gcc -O0 -o t t.c
$ readelf -s t

Symbol table '.dynsym' contains 3 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.2.5 (2)
     2: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__

Symbol table '.symtab' contains 50 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000400270     0 SECTION LOCAL  DEFAULT    1 
....
    27: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS t.c
    28: 0000000000600e14     0 NOTYPE  LOCAL  DEFAULT   18 __init_array_end
    29: 0000000000600e40     0 OBJECT  LOCAL  DEFAULT   21 _DYNAMIC

donc l'exécutable a un .symtab avec tout. Mais remarquez que .dynsym ne mentionne pas foo - c'est l'essentiel. Ce n'est pas de suffisamment d'informations pour backtrace_symbols au travail. Il s'appuie sur les informations présentes dans cette section pour faire correspondre les adresses de code avec les noms de fonction.

Maintenant compiler -rdynamic:

$ gcc -O0 -o t t.c -rdynamic
$ readelf -s t

Symbol table '.dynsym' contains 17 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.2.5 (2)
     2: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__
     3: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _Jv_RegisterClasses
     4: 0000000000601018     0 NOTYPE  GLOBAL DEFAULT  ABS _edata
     5: 0000000000601008     0 NOTYPE  GLOBAL DEFAULT   24 __data_start
     6: 0000000000400734     6 FUNC    GLOBAL DEFAULT   13 foo
     7: 0000000000601028     0 NOTYPE  GLOBAL DEFAULT  ABS _end
     8: 0000000000601008     0 NOTYPE  WEAK   DEFAULT   24 data_start
     9: 0000000000400838     4 OBJECT  GLOBAL DEFAULT   15 _IO_stdin_used
    10: 0000000000400750   136 FUNC    GLOBAL DEFAULT   13 __libc_csu_init
    11: 0000000000400650     0 FUNC    GLOBAL DEFAULT   13 _start
    12: 0000000000601018     0 NOTYPE  GLOBAL DEFAULT  ABS __bss_start
    13: 000000000040073a    16 FUNC    GLOBAL DEFAULT   13 main
    14: 0000000000400618     0 FUNC    GLOBAL DEFAULT   11 _init
    15: 00000000004007e0     2 FUNC    GLOBAL DEFAULT   13 __libc_csu_fini
    16: 0000000000400828     0 FUNC    GLOBAL DEFAULT   14 _fini

Symbol table '.symtab' contains 50 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000400270     0 SECTION LOCAL  DEFAULT    1 
....
    27: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS t.c
    28: 0000000000600e14     0 NOTYPE  LOCAL  DEFAULT   18 __init_array_end
    29: 0000000000600e40     0 OBJECT  LOCAL  DEFAULT   21 _DYNAMIC

Même chose pour les symboles .symtab, mais maintenant foo a un symbole dans la section de symbole dynamique (et un tas d'autres symboles y apparaissent aussi maintenant). Cela rend backtrace_symbols work-it dispose maintenant de suffisamment d'informations (dans la plupart des cas) pour cartographier les adresses de code avec les noms de fonction.

Bande:

$ strip --strip-all t
$ readelf -s t

Symbol table '.dynsym' contains 17 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.2.5 (2)
     2: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__
     3: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _Jv_RegisterClasses
     4: 0000000000601018     0 NOTYPE  GLOBAL DEFAULT  ABS _edata
     5: 0000000000601008     0 NOTYPE  GLOBAL DEFAULT   24 __data_start
     6: 0000000000400734     6 FUNC    GLOBAL DEFAULT   13 foo
     7: 0000000000601028     0 NOTYPE  GLOBAL DEFAULT  ABS _end
     8: 0000000000601008     0 NOTYPE  WEAK   DEFAULT   24 data_start
     9: 0000000000400838     4 OBJECT  GLOBAL DEFAULT   15 _IO_stdin_used
    10: 0000000000400750   136 FUNC    GLOBAL DEFAULT   13 __libc_csu_init
    11: 0000000000400650     0 FUNC    GLOBAL DEFAULT   13 _start
    12: 0000000000601018     0 NOTYPE  GLOBAL DEFAULT  ABS __bss_start
    13: 000000000040073a    16 FUNC    GLOBAL DEFAULT   13 main
    14: 0000000000400618     0 FUNC    GLOBAL DEFAULT   11 _init
    15: 00000000004007e0     2 FUNC    GLOBAL DEFAULT   13 __libc_csu_fini
    16: 0000000000400828     0 FUNC    GLOBAL DEFAULT   14 _fini
$ ./t
$

Aucun .symtab est parti, mais la table de symboles dynamique est toujours là, et l'exécutable s'exécute. Donc backtrace_symbols fonctionne toujours trop.

la Bande de la dynamique de la table des symboles:

$ strip -R .dynsym t
$ ./t
./t: relocation error: ./t: symbol , version GLIBC_2.2.5 not defined in file libc.so.6 with link time reference

... et vous obtenez une fracture de l'exécutable.

Une lecture intéressante pour ce qu' .symtab et .dynsym sont utilisés, c'est ici: à l'Intérieur de l'ELFE Tables de symboles. Une des choses à noter est que .symtab n'est pas nécessaire à l'exécution, il est donc rejeté par le chargeur. Cette section ne reste pas dans la mémoire du processus. .dynsym, par contre, nécessaire à l'exécution, il est donc conservé dans l'image process. Il est donc disponible pour des choses comme backtrace_symbols pour recueillir des informations sur l' processus actuel de l'intérieur de lui-même.

Donc en bref:

• symboles dynamiques ne sont pas supprimés par strip puisque cela rendrait l'exécutable Non-chargeable
• backtrace_symbols nécessite des symboles dynamiques pour comprendre quel code appartient à quelle fonction
• backtrace_symbols n'utilise pas de symboles de débogage

D'où le comportement que vous avez remarqué.

Pour votre questions:

1. gdb est un débogueur. Il utilise les informations de débogage dans l'exécutable et les bibliothèques pour afficher les informations pertinentes. C'est beaucoup plus complexe que backtrace_symbols, et inspecte les fichiers sur votre disque dur en plus du live processus. backtrace_symbols ne fonctionne pas, il est entièrement en cours de traitement-de sorte qu'il ne peut pas accéder aux sections qui ne sont pas chargées dans l'image exécutable. Les sections de débogage ne sont pas chargées dans l'image d'exécution, donc elle ne peut pas utiliser ils.
2. .dynsym n'est pas une section débogage. C'est une section utilisée par le dynamic linker. .symbtab n'est pas non plus une section de débogage, mais elle peut être utilisée par les débogueurs qui ont accès aux fichiers exécutables (et à la bibliothèque). -rdynamicne pas générer des sections de débogage, seulement cette table étendue de symboles dynamiques. La croissance exécutable de -rdynamic dépend entièrement du nombre de symboles dans cet exécutable (et des considérations d'alignement/remplissage). Il devrait être beaucoup moins que -g.
3. sauf pour les binaires statiquement liés, les exécutables ont besoin de dépendances externes résolues au moment du chargement. Comme lier printf et quelques procédures de démarrage d'application de la bibliothèque C. Ces symboles externes doivent être indiqués quelque part dans l'exécutable: c'est ce que .dynsym est utilisé pour, et c'est pourquoi le fichier exe a une .dynsym même si vous ne spécifiez pas -rdynamic. Lorsque vous ne spécifiez, le linker ajoute d'autres symboles qui ne sont pas nécessaires pour le processus de travail, mais peut être utilisé par des choses comme backtrace_symbols.
4. backtrace_symbols ne résoudra aucun nom de fonction si vous faites un lien statique. Même si vous spécifiez -rdynamic, le .dynsym la section ne sera pas émise à l'exécutable. Aucune table de symboles n'est chargée dans l'image exécutable, donc backtrace_symbols impossible de cartographier les adresses des codes aux symboles.