Comment générer un symbole de débogage gcc en dehors de la cible de génération?

Question

Je sais que je peux générer un symbole de débogage en utilisant l'option -g. Cependant, le symbole est incorporé dans le fichier cible. Gcc pourrait-il générer un symbole de débogage en dehors de l'exécutable/de la bibliothèque de résultats? Comme fichier .pdb de Windows VC++ compilateur fait.

Answer 1

Vous devez utiliser objcopy-separate the debug information:

objcopy --only-keep-debug "${tostripfile}" "${debugdir}/${debugfile}" 
strip --strip-debug --strip-unneeded "${tostripfile}" 
objcopy --add-gnu-debuglink="${debugdir}/${debugfile}" "${tostripfile}" 

J'utilise le script bash ci-dessous pour séparer les informations de débogage dans les fichiers avec une extension .debug dans un répertoire .debug. De cette façon, je peux tarer les bibliothèques et les exécutables dans un fichier tar et les répertoires .debug dans un autre. Si je veux ajouter l'information de débogage plus tard, j'extrais simplement le fichier tar de débogage et voila j'ai des informations de débogage symboliques.

Voici le script bash:

#!/bin/bash 

scriptdir=`dirname ${0}` 
scriptdir=`(cd ${scriptdir}; pwd)` 
scriptname=`basename ${0}` 

set -e 

function errorexit() 
{ 
    errorcode=${1} 
    shift 
    echo $@ 
    exit ${errorcode} 
} 

function usage() 
{ 
    echo "USAGE ${scriptname} <tostrip>" 
} 

tostripdir=`dirname "$1"` 
tostripfile=`basename "$1"` 


if [ -z ${tostripfile} ] ; then 
    usage 
    errorexit 0 "tostrip must be specified" 
fi 

cd "${tostripdir}" 

debugdir=.debug 
debugfile="${tostripfile}.debug" 

if [ ! -d "${debugdir}" ] ; then 
    echo "creating dir ${tostripdir}/${debugdir}" 
    mkdir -p "${debugdir}" 
fi 
echo "stripping ${tostripfile}, putting debug info into ${debugfile}" 
objcopy --only-keep-debug "${tostripfile}" "${debugdir}/${debugfile}" 
strip --strip-debug --strip-unneeded "${tostripfile}" 
objcopy --add-gnu-debuglink="${debugdir}/${debugfile}" "${tostripfile}" 
chmod -x "${debugdir}/${debugfile}" 

Answer 2

Découvrez l'option "--only-keep-debug" de la commande strip.

À partir du lien:

L'intention est que cette option sera utilisée conjointement avec --add-gnu-debuglink pour créer un exécutable en deux parties. Un binaire dépouillé qui occupera moins d'espace dans la RAM et dans une distribution et le second un fichier d'information de débogage qui n'est nécessaire que si des capacités de débogage sont requises.

Answer 3

Compile avec des informations de débogage:

gcc -g -o main main.c 

séparé les informations de débogage:

objcopy --only-keep-debug main main.debug 

ou

cp main main.debug 
strip --only-keep-debug main.debug 

bande des informations de débogage du fichier d'origine:

objcopy --strip-debug main 

ou

strip --strip-debug --strip-unneeded main 

débogage en mode debuglink:

objcopy --add-gnu-debuglink main.debug main 
gdb main 

Vous pouvez également utiliser le fichier exec et le fichier symbole séparemment :

gdb -s main.debug -e main 

ou

gdb 
(gdb) exec-file main 
(gdb) symbol-file main.debug 

Pour en savoir plus:

(gdb) help exec-file 
(gdb) help symbol-file 

Ref:
https://sourceware.org/gdb/onlinedocs/gdb/Files.html#Files https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html

Answer 4

NOTE: Les programmes compilés avec haut niveau de l'optimisation s (-O3, -O4) ne peut pas générer beaucoup de symboles de débogage pour les variables optimisées, les fonctions intégrées et les boucles déroulées, quels que soient les symboles incorporés (-g) ou extraits (objcopy) dans un fichier '.debug'. A) Incorporer les données de versionnement (VCS, git, svn) dans le programme, pour les exécutables optimisés par compilateur (-O3, -O4).
b) Construire une deuxième version non optimisée de l'exécutable.

La première option fournit un moyen de reconstruire le code de production avec un débogage complet et des symboles à une date ultérieure. Etre capable de reconstruire le code de production original sans optimisations est une aide précieuse pour le débogage. (NOTE: Cela suppose que le test a été fait avec la version optimisée du programme).

Votre système de génération peut créer un fichier .c chargé avec la date de compilation, la validation et d'autres détails VCS. Voici un make + git 'exemple:

program: program.o version.o 

program.o: program.cpp program.h 

build_version.o: build_version.c  

build_version.c: 
    @echo "const char *build1=\"VCS: Commit: $(shell git log -1 --pretty=%H)\";" > "$@" 
    @echo "const char *build2=\"VCS: Date: $(shell git log -1 --pretty=%cd)\";" >> "$@" 
    @echo "const char *build3=\"VCS: Author: $(shell git log -1 --pretty="%an %ae")\";" >> "$@" 
    @echo "const char *build4=\"VCS: Branch: $(shell git symbolic-ref HEAD)\";" >> "$@" 
    # TODO: Add compiler options and other build details 

.TEMPORARY: build_version.c 

Une fois le programme compilé, vous pouvez localiser le « commit » original pour votre code en utilisant la commande: strings -a my_program | grep VCS

VCS: PROGRAM_NAME=my_program 
VCS: Commit=190aa9cace3b12e2b58b692f068d4f5cf22b0145 
VCS: BRANCH=refs/heads/PRJ123_feature_desc 
VCS: AUTHOR=Joe Developer joe.developer@somewhere.com 
VCS: COMMIT_DATE=2013-12-19 

Tout ce qui reste est de vérifier le code d'origine, recompiler sans optimisations, et commencer le débogage.