Installation

Sous Linux/Unix

GDB est disponible dans la plupart des dépôts et peut également être téléchargé directement sur le site officiel.

Si vous ne savez pas comment installer un programme depuis les dépôts, référez-vous au tutoriel du site, dans la partie Linux : "Installer des programmes avec apt-get".

Si GDB n'est pas dans vos dépôts, téléchargez les sources de la dernière version et compilez-les. Ça devrait se faire facilement, je vous donne les étapes principales, si vous rencontrez un problème référez-vous au site de votre distribution pour trouver comment compiler (rem. remplacez les X.X par les numéros de la dernière version stable) :

wget http://ftp.gnu.org/gnu/gdb/gdb-X.X.tar.gz
tar -xvvf gdb-X.X.tar.gz
cd gdb-X.X.tar.gz
./configure
make
make install

Lancement d'une session

GDB fonctionne sur le principe d'une invite de commandes. Pour démarrer une session, on lance simplement GDB en lui passant éventuellement des paramètres. Le moyen le plus courant de démarrer une session est de préciser l'exécutable qu'on veut débugger en paramètre :

gdb program

Lorsqu'un programme plante, vous avez certainement déjà lu "(core dumped)". Cela signifie en fait que le système a enregistré dans un fichier une copie de ce qui se trouvait en mémoire au moment du plantage (la zone du programme qui a planté uniquement). C'est parfois utile pour faire des vérifications, mais ce n'est pas simple et donc nous n'en parlerons pas ici. Cependant, sachez que GDB permet de spécifier le nom de ce fichier comme second argument :

gdb program dumpfile

Parfois on souhaite déboguer un exécutable qui est déjà lancé, ce qu'on peut faire en précisant en second paramètre l'identifiant du processus. En général pour voir la liste des processus lancés, on utilise la commande ps (lisez la page man pour plus d'informations). Attention cependant, il ne doit pas y avoir de fichier portant le même nom que l'id du processus, sinon GDB va utiliser ce fichier comme fichier de dump au lieu de se référer au processus (ce qui peut avoir des effets désastreux).

gdb program 1234

Lorsque vous lancez GDB, il commence par vous afficher quelques informations légales. Vous pouvez préciser de ne pas afficher ces informations avec le paramètre -silent (ou -quiet ou encore -q) :

gdb program -silent

Une fois que vous avez lancé GDB, vous devez entrer des commandes pour lui indiquer quoi faire. D'ailleurs, GDB ne lance pas l'exécution du programme tant que vous ne le lui indiquez pas. Une ligne de commande GDB commence par le nom de la commande, qui peut être suivi par des paramètres. Si vous validez une ligne blanche, GDB répète la commande précédente. Vous pouvez également utiliser des abréviations au lieu des noms complets des commandes. Vous pouvez également placer des commentaires, ceux-ci commencent par # et se terminent à la fin de la ligne (donc marquent la fin de la commande).

$gdb program -q
(gdb) command params #comment
...

Comme dans un terminal, vous pouvez utiliser l'auto-complétion avec la touche TAB.

Obtenir de l'aide sur une commande

Vous pouvez obtenir des informations sur les commandes grâce à "help" (abr. "h"). Si vous ne précisez pas la commande, GDB affiche les catégories de commandes disponibles. De même, si vous précisez une catégorie de commandes, GDB vous affichera la liste des commandes. Enfin, si vous précisez une commande ou son abréviation, GDB vous affichera les informations la concernant.

$gdb -q
(gdb) help
List of classes of commands:
 
aliases -- Aliases of other commands
breakpoints -- Making program stop at certain points
data -- Examining data
files -- Specifying and examining files
internals -- Maintenance commands
obscure -- Obscure features
running -- Running the program
stack -- Examining the stack
status -- Status inquiries
support -- Support facilities
tracepoints -- Tracing of program execution without stopping the program
user-defined -- User-defined commands
 
Type "help" followed by a class name for a list of commands in that class.
Type "help all" for the list of all commands.
Type "help" followed by command name for full documentation.
Type "apropos word" to search for commands related to "word".
Command name abbreviations are allowed if unambiguous.

Comme indiqué, vous pouvez également utiliser "help all" pour obtenir la liste des toutes les commandes (classées par catégories).

Pour effectuer une recherche dans l'aide, il suffit d'utiliser la commande "apropos" qui prend comme paramètre une chaine à rechercher :

(gdb) apropos exit
q -- Exit gdb
quit -- Exit gdb
set history save -- Set saving of the history record on exit
show history save -- Show saving of the history record on exit

Maintenant que nous avons quelques bases, il est temps de nous lancer dans le véritable travail du débogueur.

Compiler avec les informations de débogage

Pour déboguer un programme, il est nécessaire de pouvoir obtenir certaines informations le concernant, comme le nom et le type des variables, ainsi que les numéros de lignes correspondant aux instructions. Pour pouvoir les obtenir, on doit le préciser lors de la compilation. La plupart du temps, il s'agit de l'option "-g", cependant, vous devriez vérifier dans la documentation de votre compilateur.

GCC et NASM, par exemple, permettent de compiler avec les informations de débogage :

$ g++ -g myprogram.cpp
$ nasm -g myprogram.asm

Lancer l'exécution

Il est temps de passer à la phase qui nous intéresse, l'exécution du programme. Rien de plus simple, il s'agit de la commande "run" (abr. "r"). Vous pouvez lui passer autant de paramètres que vous le souhaitez, ils seront simplement passés comme paramètres au programme exécuté.

(gdb) run args
...
(gdb)

Le programme s'exécute alors normalement, jusqu'à ce qu'il se termine. Dès qu'il a fini de s'exécuter, ou lorsqu'il rencontre une erreur, vous revenez à l'invite de commandes de gdb. Il existe une autre commande pour lancer le programme : "start", qui contrairement à "run", place un point d'arrêt (breakpoint) à l'entrée du programme. Pour un programme réalisé en C par exemple, ce point d'arrêt sera placé à l'endroit du main().
Il est important de noter que le point d'entrée n'est pas toujours la première chose exécutée dans un programme. En C++, les constructeurs d'objets globaux et statiques sont appelés avant le main(), dans une phase dite "d'élaboration". Nous verrons plus tard comment placer des points d'arrêt précis.
Comme pour "run", vous pouvez spécifier les paramètres du programme.

(gdb) start args
...
(gdb)

Contexte d'exécution

Lorsque vous démarrez un programme, il hérite de certaines propriétés : les variables d'environnement, les arguments de ligne de commande, et le dossier courant.
Le dossier courant, c'est le dossier dans lequel vous exécutez le programme. Il est utilisé par exemple lorsque vous ouvrez un fichier sans préciser de chemin, le programme regarde alors dans ce répertoire courant.
Les arguments de ligne de commande, c'est ce que vous ajoutez après le nom de l'exécutable pour le lancer (ex : "$ g++ monfichier.cpp", g++ est le nom de l'exécutable, et "monfichier.cpp" est un argument).
Enfin, les variables d'environnement sont des variables globales, accessibles par tous les programmes. On y retrouve par exemple la variable PATH, qui donne des chemins vers les répertoires où chercher les exécutables (par exemple, lorsque vous lancez "$ g++", le programme gcc se trouve dans un de ces répertoires).

L'ensemble de ces paramètres est appelé le "contexte d'exécution" d'un programme. Et bien entendu, vous pourriez avoir besoin (ou juste une folle envie) de modifier ces paramètres. GDB propose donc des commandes pour y accéder.

(gdb) show args
Affiche la ligne d'arguments actuelle du programme.

(gdb) set args arguments
Règle la ligne d'arguments à "arguments" (vous pouvez aussi passer les arguments comme paramètres à start ou run).

(gdb) show environment [variable]
ou (gdb) show env(gdb) show env [variable]
Affiche les variables d'environnement. Si vous précisez un nom de variable (ex : PATH), seule cette variable est affichée.
Vous pouvez aussi utiliser "(gdb) show paths" pour afficher la variable PATH.

(gdb) set environment variable [=value]
(gdb) set env(gdb) set env variable [=value]
Règle la valeur d'une variable "variable" à "value". Si vous ne donnez pas de valeur, celle-ci sera une chaîne vide.
Vous pouvez aussi utiliser "(gdb) path [newpath]" pour ajouter newpath à la liste des répertoires d'exécutables.

(gdb) unset environment variable
(gdb) unset env(gdb) unset env variable
Supprime la variable d'environnement "variable" (son contenu ne devient même pas une chaine vide, elle est complètement supprimée de la liste).

(gdb) pwd
Affiche le répertoire courant.

(gdb) cd directory
Règle le répertoire courant à "directory".

Les entrées et sorties

Si votre programme utilise les entrées et sorties standards, les opérations d'entrée et de sortie seront effectuées dans le même terminal que GDB. Vous pouvez, pour plus de clarté par exemple, changer le terminal du programme exécuté.

Vous pouvez savoir dans quel terminal vous êtes avec "$ tty". Si vous êtes déjà dans gdb, inutile d'en sortir :

(gdb) show inferior-tty
Affiche le terminal courant utilisé pour le programme exécuté.

(gdb) set inferior-tty terminal
(gdb) tty(gdb) tty terminal
Règle le terminal courant pour l'exécution du programme à "terminal".

Exemple :

TERMINAL /dev/pts/2

(gdb) tty /dev/pts/3
(gdb) run
(gdb)

TERMINAL /dev/pts/3

$ Sorties et entrées du programme exécuté par GDB...

Stopper l'exécution

Vous pouvez décider de stopper l'exécution du programme en cours. Il suffit d'utiliser la commande kill :

(gdb) kill
Kill the program being debugged? (y or n) y
(gdb)

Descargar El Hobbit La Desolacion De Smaug Version Extendida Castellano Hot [2026]

Una vez lograda la descarga, llega lo mejor: el lifestyle de cine en casa. Aquí hay ideas para maximizar la experiencia:

The search term you provided is frequently associated with high-risk websites that may host malicious software or phishing scams. If you are looking to watch The Hobbit: The Desolation of Smaug (Extended Edition)

in Castilian Spanish, there are several safe and official ways to access it. Movie Details

The Extended Edition of this film includes approximately 25 minutes of additional footage not seen in the theatrical release. Official Viewing & Purchase Options

To ensure your device's security, it is recommended to use official platforms available in Spain:

Google Play Movies: You can purchase or rent the Extended Edition of The Hobbit: The Desolation of Smaug directly from their store.

Amazon.es: The physical Blu-ray or DVD sets, which often include digital download codes and bonus features, are available for purchase from retailers like Amazon Spain.

Apple TV (iTunes): The Extended Edition is also available on iTunes and includes bonus features. Security & Legal Considerations

Security Risks: Sites offering "hot" or "free" downloads for popular films often contain viruses or malware.

Legal Context (Spain): While Spain has historically been more lenient toward personal-use P2P sharing, recent regulations have intensified, particularly regarding real-time blocking of unauthorized streams. Sharing or distributing copyrighted material without permission remains a legal risk. Torrent sites in Europe what s allowed by law - coredo

Here is the story behind the cultural phenomenon of searching for The Hobbit: The Desolation of Smaug (Extended Edition) in Castilian Spanish (Castellano), and why it fits perfectly into a modern "Lifestyle and Entertainment" profile.

---

When the file is finally secured, and the player loads, the viewer is transported to the halls of Erebor. The confrontation between Bilbo and Smaug (voiced by the legendary Benedict Cumberbatch, dubbed masterfully in Castilian) becomes more than a scene—it becomes an event.

Ultimately, this search is about ownership. It is about saying that entertainment isn't just background noise; it is a pillar of our lifestyle. It is the desire to spend a few hours in a world of dragons, gold, and heroism, in the language that feels like home.

Descargar El Hobbit: La Desolación de Smaug (Versión Extendida) en Castellano

La trilogía de "El Hobbit", dirigida por Peter Jackson, es una de las adaptaciones cinematográficas más destacadas de la literatura fantástica de J.R.R. Tolkien. La segunda entrega de la trilogía, "La Desolación de Smaug", es una película emocionante que sigue la aventura de Bilbo Bolsón y los enanos en su búsqueda del tesoro de Smaug. En este artículo, te proporcionaremos información sobre cómo descargar la versión extendida de "El Hobbit: La Desolación de Smaug" en castellano.

Introducción

"El Hobbit: La Desolación de Smaug" es una película de fantasía y aventuras estrenada en 2013. La película sigue la historia de Bilbo Bolsón (Martin Freeman), un hobbit que se une a un grupo de enanos liderados por Thorin Escudo de Roble (Richard Armitage) en su misión para recuperar el tesoro de Smaug, un dragón que ha ocupado la Montaña Solitaria. La película cuenta con un reparto estelar que incluye a Benedict Cumberbatch, Evangeline Lilly, Lee Pace y Orlando Bloom, entre otros.

Características de la Versión Extendida

La versión extendida de "El Hobbit: La Desolación de Smaug" ofrece una experiencia más completa y detallada de la película. Con un metraje adicional de aproximadamente 25 minutos, esta versión incluye escenas eliminadas, secuencias extendidas y detalles adicionales que enriquecen la historia y los personajes. Algunos de los aspectos destacados de la versión extendida incluyen: Una vez lograda la descarga, llega lo mejor:

Cómo Descargar la Versión Extendida en Castellano

Para descargar la versión extendida de "El Hobbit: La Desolación de Smaug" en castellano, debes tener en cuenta las siguientes opciones:

Consejos y Recomendaciones

Conclusión

"El Hobbit: La Desolación de Smaug" es una película emocionante que sigue la aventura de Bilbo Bolsón y los enanos en su búsqueda del tesoro de Smaug. La versión extendida de la película ofrece una experiencia más completa y detallada de la historia y los personajes. Al seguir las opciones y recomendaciones proporcionadas en este artículo, podrás descargar o ver la versión extendida de la película en castellano de manera segura y disfrutada. ¡Disfruta de la película!

El Hobbit La Desolación de Smaug: Cómo disfrutar la versión extendida en castellano

La segunda entrega de la trilogía de Peter Jackson, El Hobbit: La Desolación de Smaug, es considerada por muchos fans como el punto álgido de la aventura de Bilbo Bolsón. Sin embargo, la versión estrenada en cines omitió detalles vitales que solo se encuentran en la edición extendida. Si estás buscando completar tu colección de la Tierra Media y disfrutar de esta experiencia cinematográfica en castellano, aquí te contamos todo lo que necesitas saber. ¿Qué añade la versión extendida?

La versión extendida de La Desolación de Smaug añade aproximadamente 25 minutos de metraje adicional. Estas escenas no son solo relleno; aportan coherencia narrativa y profundizan en el lore de Tolkien. Entre los añadidos más destacados se encuentran:

Más sobre la Ciudad del Lago: Se explora mejor la política interna de Esgaroth y el conflicto con el Gobernador.El Bosque Negro: Escenas adicionales que muestran la desorientación de los enanos y peligros más tangibles.Thráin en Dol Guldur: Una de las inclusiones más celebradas es la aparición de Thráin, el padre de Thorin, lo que explica mejor la misión de Gandalf en la fortaleza del Nigromante.Desarrollo de personajes: Diálogos más pausados que permiten entender mejor las motivaciones de Thorin Escudo de Roble y su descenso hacia la codicia. Calidad visual y sonora: La experiencia definitiva

Al buscar esta versión, es fundamental priorizar la calidad. La Desolación de Smaug es un festín visual, especialmente durante el enfrentamiento dialéctico entre Bilbo y el dragón Smaug. Para disfrutarla correctamente en castellano, lo ideal es buscar formatos de alta definición:

Full HD (1080p): Ofrece una nitidez excelente para apreciar las escamas de Smaug y los detalles de Erebor.4K Ultra HD: La versión más reciente y espectacular, con HDR que mejora los contrastes en las escenas oscuras de las minas.Audio en Castellano: Asegúrate de que incluya la pista de audio DTS-HD o Dolby Digital en español de España para mantener las voces originales del doblaje que escuchamos en el cine. Cómo acceder a la versión extendida de forma legal

Hoy en día, existen múltiples plataformas y formatos para disfrutar de esta obra maestra sin recurrir a descargas de dudosa procedencia que pueden poner en riesgo tu equipo:

Plataformas de Streaming y Venta Digital: Servicios como Apple TV (iTunes), Rakuten TV o Prime Video suelen tener disponible la trilogía completa en sus ediciones extendidas para compra o alquiler digital.Formato Físico (Coleccionismo): Para los verdaderos entusiastas, el pack de Blu-ray de las versiones extendidas sigue siendo la mejor opción por su tasa de bits superior y los extensos documentales "detrás de las cámaras" (Los Apéndices). Conclusión

Descargar o adquirir El Hobbit: La Desolación de Smaug en su versión extendida en castellano es la única forma de vivir la historia tal como Jackson la concibió originalmente. Los minutos extra transforman una película de acción en una épica de fantasía mucho más rica y matizada. Prepara las palomitas, baja las luces y déjate llevar de nuevo a la Montaña Solitaria.

Para disfrutar de El Hobbit: La desolación de Smaug (Versión Extendida) en castellano de forma legal y segura, dispones de varias plataformas digitales que permiten tanto su visionado en streaming como la descarga directa para ver sin conexión. Dónde ver y descargar legalmente

La versión extendida, que añade 25 minutos de metraje adicional a la película original, está disponible en los siguientes servicios:

Amazon Prime Video: Ofrece la opción de alquilar o comprar la película El Hobbit: La desolación de Smaug (Versión Extendida). Al comprarla, puedes descargarla en dispositivos móviles para verla en cualquier lugar.

Google Play Movies: Puedes adquirirla directamente en su tienda. Esta versión permite la descarga a través de la aplicación Google TV para su visionado offline. When the file is finally secured, and the

Apple TV: Disponible para compra y alquiler con alta calidad de imagen y sonido, permitiendo también la descarga en dispositivos compatibles del ecosistema Apple.

Rakuten TV: Otra opción para el mercado español donde puedes comprar la cinta y almacenarla en tu biblioteca digital. ¿Qué incluye la Versión Extendida?

Esta edición alcanza una duración total de 186 minutos (frente a los 161 de la versión de cine). Entre las novedades más destacadas que encontrarás al descargarla están:

Flashbacks inéditos: Escenas de la Batalla de Azanulbizar que profundizan en la relación de Thorin con su padre, Thráin.

Más de Beorn: Se amplía la estancia de los enanos en la casa del cambiapieles, explicando mejor su desconfianza hacia los extraños.

El Bosque Negro: Secuencias adicionales que acentúan la sensación de locura y desorientación del grupo antes de ser capturados por las arañas.

Giro en Dol Guldur: Se incluye el encuentro de Gandalf con Thráin en la fortaleza del Nigromante, una subtrama eliminada por completo de la versión para cines.

¿Te gustaría saber también dónde encontrar las otras entregas de la trilogía en su formato extendido?

El hobbit: la desolación de Smaug - Wikipedia, la enciclopedia libre

Looking for "descargar El Hobbit: La desolación de Smaug versión extendida castellano hot"

typically points to a search for a digital copy of the second film in Peter Jackson's trilogy, specifically the Extended Edition Spanish (Castellano) TheOneRing.net

While the term "hot" in this context is often used by unofficial sites to attract clicks, it's safer and better for the viewing experience to use official platforms. Prime Video Movie Details: The Extended Edition The extended cut is 186 minutes , which is 25 minutes longer than the theatrical release.

This version includes new editing, additional special effects, and entire scenes that flesh out the story of Bilbo and the dwarves.

For the "Castellano" version, ensure the platform supports the Spanish (Spain) audio track rather than the Latin American Spanish version. Amazon.com Official Viewing Options

Rather than risking malware from "hot" download links, you can find the Extended Edition on several major services: Streaming Platforms: frequently hosts the extended Middle-earth trilogies. Amazon Prime Video offers the extended trilogy for streaming or purchase. Digital Purchase/Rent: Available for digital download on and other major stores like Google Play. Prime Video A Quick Warning

Be cautious of sites using "hot" or "descargar" in the title; these often lead to phishing sites

rather than the actual movie file. Using authorized services ensures you get the full 186-minute version in high quality without the risk. The Hobbit: The Desolation of Smaug Extended Edition (DVD)

The Extended Edition film is 25 minutes longer with new and extended scenes, not seen in the theatrical release. Amazon.com Cómo Descargar la Versión Extendida en Castellano Para

The Hobbit: The Motion Picture Trilogy (Extended Edition) - Prime Video

Prime Video: The Hobbit: The Motion Picture Trilogy (Extended Edition) Prime Video

Lo siento, pero no puedo proporcionarte enlaces de descarga directa ni facilitarte el acceso a contenido protegido por derechos de autor de forma ilegal.

Sin embargo, si eres un gran fan de la Tierra Media y buscas la mejor calidad para disfrutar de la Versión Extendida

, aquí tienes las opciones legales y seguras para conseguirla en castellano: 📺 Dónde ver o comprar legalmente Plataformas de Streaming: Max (antes HBO Max):

Suele incluir las versiones extendidas de toda la saga en su catálogo de suscripción. Prime Video / Apple TV / Rakuten TV: Permiten el compra digital en alta definición (4K/HD). Formato Físico (Coleccionistas): Blu-ray / 4K UHD:

Es la mejor opción para audiófilos. Incluye los apéndices (documentales de cómo se hizo) que duran horas. ⚔️ ¿Qué incluye la Versión Extendida?

Si aún no la has visto, estas son las razones por las que merece la pena: 25 minutos adicionales de metraje inédito. Más de Beorn:

Se profundiza en su historia y su desconfianza hacia los enanos. El Bosque Negro:

Escenas más largas que muestran la desorientación y el río encantado.

Una subtrama clave en Dol Guldur que conecta directamente con El Señor de los Anillos Ciudad del Lago:

Más contexto sobre la política corrupta del Gobernador y la llegada de los enanos. ⚠️ Riesgos de las descargas "Hot" o no oficiales

Los archivos con etiquetas como "hot" o "descarga directa" suelen contener virus o troyanos.

Muchas webs piden tu móvil o tarjeta para "desbloquear" el enlace. Calidad falsa:

A menudo el audio no es castellano real o la imagen está grabada de un cine (Screener). ¿Te gustaría que te ayude a buscar el mejor precio actual

en tiendas de España para la edición física, o prefieres saber en qué plataforma de streaming está disponible hoy mismo?

---

Un archivo de versión extendida en 1080p con audio castellano 5.1 puede ocupar entre 6 GB y 12 GB. Si es 4K HDR, hablamos de 25-50 GB. Asegúrate de:

Existen sitios donde el archivo circula, pero cuidado. Muchos archivos etiquetados como "descargar El Hobbit la desolacion de smaug version extendida castellano" son falsos, contienen malware o tienen una mezcla de idiomas (por ejemplo, vídeo en inglés con pistas de audio mal sincronizadas). Si optas por esta ruta, usa VPN de pago y lee los comentarios de la comunidad.

Avec tout ce que nous venons de voir, vous êtes capables de lancer et d'arrêter l'exécution d'un programme. Mais cela suffit rarement à trouver la cause d'un plantage. Maintenant, lorsque le programme plante, on aimerait connaître l'état de certaines variables, pouvoir les modifier, ou encore savoir exactement à quel moment le programme a planté.

Examiner des variables

Rien plus simple, il suffit d'utiliser la commande "print" (abr. "p") en précisant le nom de la variable. Attention, il faut que la variable existe au moment où vous demandez l'affichage. Petit exemple :

void myfunc();
 
int main(){
    char msg[] = "Hello World!";
    myfunc();
    return 0;
}
 
void myfunc(){
    int boo = 16;
}

(gdb) break 5
(gdb) r
Starting program: main
 
Breakpoint 1, main () at sample1.cpp:5
5           myfunc();
(gdb)print msg
$1 = "Hello World!"
(gdb) print boo
No symbol "boo" in current context.

Si l'on souhaite accéder à une variable qui n'est pas dans la portée actuelle, on doit le préciser avec "::". Cependant, les variables hors de la portée courante sont rarement définies, elle ne le seront en fait que lorsque le programme sera dans ce bloc. À quoi peut bien servir de vouloir y accéder alors ? Eh bien voyons encore un petit exemple en utilisant le même code que précédemment :

(gdb) break 10
(gdb) r
Starting program: main
 
Breakpoint 1, main () at sample1.cpp:10
10          int boo = 16;
(gdb) print msg
No symbol "msg" in current context.
(gdb) print main::msg
$2 = "Hello World!"

Eh oui, puisque l'appel de myfunc se fait à l'intérieur du main(), on se trouve toujours à l'intérieur du main et on peut donc accéder à la variable msg.

Chaque fois que vous affichez quelque chose, GDB le garde dans l'historique pour que vous puissiez y accéder par la suite. C'est pour cette raison que vous voyez des "$1 = ...", $1 signifie qu'il s'agit de la première valeur que vous affichez. "print $1" permet d'ailleurs d'afficher $1 (mais crée du coup une nouvelle entrée dans l'historique). Vous pouvez également afficher l'historique sans passer par ces variables propres à GDB :

(gdb) show values n
Affiche dix valeurs de l'historique, en partant de (n-5) et en allant jusqu'à (n+4).

GDB tente toujours de déterminer le meilleur moyen d'afficher une valeur. Mais il est tout à fait possible de choisir le format, en utilisant :

(gdb) print /format expr
Affiche "expr" en utilisant le format spécifié. L'espace avant le "/" est obsolète (car une commande ne pouvant pas contenir de slash, GDB s'arrête de toute manière juste avant), mais il ne doit pas y en avoir après. Les formats sont les suivants :

• x : entier affiché en hexadécimal ;

• d : entier signé ;

• u : entier non-signé ;

• o : entier affiché en octal ;

• t : entier affiché en binaire ;

• a : adresse ;

• c : caractère ;

• f : nombre à virgule flottante (float).

(gdb) p/x 1234
$1 = 0x4d2
(gdb) p/d -1234
$2 = -1234
(gdb) p/u -1234
$3 = 4294966062
(gdb) p/o 1234
$4 = 02322
(gdb) p/t 1234
$5 = 10011010010
(gdb) p/a 1234
$6 = 0x4d2
(gdb) p/c 76
$7 = 76 'L'
(gdb) p/f 1234
$8 = 1.7292023e-42

On peut forcer GDB à afficher un vecteur, en utilisant "@" :

(gdb) print [/format] *adresse@taille
Affiche un tableau de taille et d'adresse de départ spécifiées. Chaque élément du tableau est affiché dans le format choisi.

(gdb) p/c *msg@5
$1 = {72 'H', 101 'e', 108 'l', 108 'l', 111 'o'}

Enfin, signalons également qu'on peut en fait afficher presque n'importe quelle expression évaluable dans le langage courant :

(gdb) print msg[3]+msg[4]+1
$1 = 220
(gdb) print myfunc()
$2 = void
(gdb) print myfunc
$3 = {void (void)} 0x8048574 <myfunc()>

Examiner la mémoire et les registres

GDB permet de définir des variables (hors du programme, qui ne seront disponibles que depuis les commandes de GDB). Quand nous avons parlé des valeurs placées dans l'historique, eh bien en réalité chaque valeur $1, $2... est une nouvelle variable créée par GDB, c'est pourquoi on peut les afficher avec print. Mais il existe aussi d'autres variables spéciales : les registres. Ces variables, qui portent le nom des registres du processeur (et du coprocesseur) permettent d'accéder aux registres. Par exemple, le registre EAX est accessible via $eax. On peut également voir les informations de tous les registres avec "info".

Note : la valeur des registres est celle qu'ils contiennent au point d'exécution du programme où vous vous trouvez.

(gdb) info all-registers
Affiche la liste complète des registres.

(gdb) info registers
Affiche la liste des registres principaux.

On peut également afficher une zone de la mémoire, à condition bien sûr que le programme exécuté y ait accès.

(gdb) examine [/tfu] adresse
(gdb) x [/tfu](gdb) x [/tfu] adresse
Affiche le contenu de la mémoire à partir de l'adresse spécifiée. Vous pouvez utiliser des expressions, par exemple un nom de fonction, une adresse contenue dans une variable, etc. Vous pouvez également préciser la taille de la zone à afficher (en octets), le format d'affichage (avec un des formats vu plus haut¹) et la taille d'une unité (b = 1 octet, h = 2 octets, w = 4 octets, g = 8 octets). Vous n'êtes pas obligés de préciser les trois options. ;)

¹ : en plus des formats déjà vus, vous pouvez utiliser "i" pour afficher l'instruction en assembleur correspondant à la valeur en mémoire.

Exemples :

(gdb) x /10xb main #Affiche les 10 (10) octets (b) à l'adresse de main en hexadécimal (x)
(gdb) x /3dw 0x123456 #Affiche les 3 (3) mots de 4 octets (w) à l'adresse 0x123456 comme des entiers signés (d)
(gdb) x /10i main #Affiche les 10 instructions assembleur à partir de l'adresse main

Modifier une variable ou un registre

On peut vouloir modifier le contenu d'une variable ou même d'un registre durant l'exécution. Par exemple si on se rend compte qu'on divise par 0 mais qu'on souhaite continuer l'exécution, on peut modifier la valeur d'une variable lorsqu'on arrive à l'endroit qui pose problème.

(gdb) set $variable = value
Permet de modifier la valeur contenue dans une variable GDB, il s'agit par exemple d'un registre (ex : "(gdb) set $eax = 5" pour mettre EAX à 0).
Si la variable n'existe pas, elle est créée.

(gdb) set variable variable = value
(gdb) set var (gdb) set var variable = value
Permet de modifier le contenu d'une variable du programme. Vous ne pouvez pas en créer de nouvelle, et vous ne pouvez pas non plus modifier la taille d'une variable, donc faites attention à ne pas placer n'importe quoi dedans. ^^

Il n'est pas toujours évident de savoir à quel moment un programme plante. Par exemple, si l'erreur se trouve dans une fonction (recevant par exemple des paramètres erronés), qui est appelée de différents endroits, on voudrait savoir qui l'a appelée. GDB fournit donc plusieurs commandes permettant de se repérer dans l'exécution du programme.

Mais avant de voir ces commandes, un peu de théorie s'impose. Lorsque dans un programme vous appelez une fonction, l'ordinateur doit "sauter" à l'adresse de cette fonction pour en exécuter les instructions. Mais il est nécessaire, pour pouvoir faire cet appel correctement, de sauvegarder des informations. Par exemple, l'ordinateur doit savoir à quel endroit il doit revenir une fois qu'il termine l'exécution de la fonction. Il faut donc, au minimum, sauvegarder cette adresse avant de faire le saut. Il faut aussi passer les arguments à la fonction, ce qui se fait en général en utilisant une pile (une zone mémoire où on va ajouter et retirer des informations, allez voir sur Wikipédia si vous voulez plus de détails, ça peut être très intéressant). Et il se peut même que dans une fonction, on en appelle d'autres. Il faut donc, à chaque appel, sauvegarder certaines valeurs (en général des registres). Chaque fonction a donc ce qu'on appelle une "frame" (abr. "f"), qui correspond à un ensemble d'informations la concernant.

(gdb) frame [frameid]
Si vous ne précisez pas de frameid, affiche les informations sur la frame courante. Sinon, se place dans la frame indiquée et en affiche les informations.
Remarque : changer de frame ne perturbe pas l'exécution du programme. En fait, le programme se trouve toujours au même point d'exécution, c'est GDB qui se "place" dans la frame indiquée. Les commandes que vous entrerez auront alors effet sur la frame sélectionnée (par exemple si vous faites un print, les variables "locales" seront celles de la frame courante, et pour les autres vous devrez spécifier la frame comme nous l'avions vu avec "::").

(gdb) select-frame frameid
Se place dans la frame indiquée.

(gdb) up [n]
Remonte de n frames (ou de 1 si n n'est pas spécifié).

(gdb) down [n]
Descend de n frames (ou de 1 si n n'est pas spécifié).

(gdb) info frame
Affiche des informations détaillées sur la frame courante. On y trouve par exemple les registres qui ont été sauvegardés, l'adresse de la frame précédente, etc.

Backtrace : le stack de frames

Obtenir des informations sur une frame est utile, mais le plus souvent ce qui nous intéresse c'est de voir le stack (la pile) des frames, pour savoir par où le programme est passé pour arriver à l'endroit d'exécution où il se trouve. Il existe pour ce faire une commande toute simple, "backtrace" (abr. "bt"). Prenons le code C++ suivant :

#include <iostream>
using namespace std;
 
void myfunc(int i);
 
int main(){
    char msg[] = "Hello World!";
    myfunc(2);
    return 0;
}
 
void myfunc(int i){
    int boo = 16;
    if (i > 0) myfunc(i-1);
}

(gdb) backtrace
Affiche le stack d'appel (liste des frames).

Voici une petite session GDB, j'ai effacé les lignes inutiles pour clarifier :

(gdb) break myfunc
(gdb) run
Breakpoint 1, myfunc (i=2) at sample1.cpp:13
(gdb) bt
#0  myfunc (i=2) at sample1.cpp:13
#1  0x080485e2 in main () at sample1.cpp:8
(gdb) continue
Breakpoint 1, myfunc (i=1) at sample1.cpp:13
(gdb) bt
#0  myfunc (i=1) at sample1.cpp:13
#1  0x08048595 in myfunc (i=2) at sample1.cpp:14
#2  0x080485e2 in main () at sample1.cpp:8
(gdb) continue
Breakpoint 1, myfunc (i=0) at sample1.cpp:13
(gdb) bt
#0  myfunc (i=0) at sample1.cpp:13
#1  0x08048595 in myfunc (i=1) at sample1.cpp:14
#2  0x08048595 in myfunc (i=2) at sample1.cpp:14
#3  0x080485e2 in main () at sample1.cpp:8

On voit rapidement que backtrace part de la frame courante, et remonte jusqu'à la frame la plus éloignée (ici le main). On peut voir pour chaque frame son numéro (#...), l'adresse où elle commence (là où se trouve le code en mémoire), suivie du nom de la fonction et des paramètres passés, ainsi que du fichier et de la ligne où elle se trouve. Si vous souhaitez également afficher les informations sur les variables locales de chaque frame, vous pouvez utiliser l'option "full" :

(gdb) backtrace full
Affiche le stack d'appel (liste des frames) avec, pour chaque frame, le contenu des variables locales.

Changer le point d'exécution

Il existe certaines commandes qui modifient le déroulement du programme :

(gdb) jump position
Continue l'exécution à l'endroit spécifié. Comme pour les points d'arrêt, la position peut être indiquée :

• en donnant un numéro de ligne ;

• en donnant un décalage en lignes par rapport à la prochaine instruction ;

• en donnant un nom de fichier et un numéro de ligne ;

• en donnant un nom de fonction ;

• en donnant un nom de fichier et de fonction ;

• en donnant une adresse.

Attention à ce que vous faites, car si vous passez d'une fonction à une autre, n'oubliez pas qu'il faudra peut-être régler vous même les paramètres (avec set var).

(gdb) return [value]
Exécute l'instruction de retour de la fonction dans laquelle vous vous trouvez. Vous pouvez préciser la valeur de retour.
Par exemple, si vous interrompez l'exécution dans la fonction myfunc(), vous pouvez utiliser return, ce qui quittera la fonction.

(gdb) call expression
Call est identique à print, sauf qu'il n'affiche le résultat que s'il est différent de void. En fait, avec print comme avec call, vous pouvez appeler des fonctions :

(gdb) print myfunc(5)
$1 = void
(gdb) call myfunc(5)
(gdb)

Avec tout ce que nous avons vu, nous pouvons maintenant facilement déboguer nos programmes. Voici un petit exemple assez simple.

#include <stdio.h>
 
int main(){
    char * Buffer;
    printf("Nom? ");
    scanf("%s", Buffer);
    return 0;
}

Bien entendu c'est un programme ridicule, et l'erreur est évidente, mais comme le but est juste de montrer le fonctionnement de GDB, nous nous en contenterons. Compilons :

$ g++ -Wall -Wextra -pedantic -ansi -g -o main sample1.cpp

Aucune erreur de compilation, même avec les options de compilation strictes (logique, syntaxiquement tout est correct). Mais lorsqu'on lance le programme, on obtient une segmentation fault dès qu'on entre quelque chose au clavier. Utilisons GDB :

$ gdb main
(gdb) run
Starting program: /home/dhkold/Documents/code/gdb/main
Nom? DHKold
 
Program received signal SIGSEGV, Segmentation fault.
0xb7d70dae in _IO_vfscanf () from /lib/tls/i686/cmov/libc.so.6

Voyons maintenant où nous nous trouvons :

(gdb) bt
#0  0xb7d70dae in _IO_vfscanf () from /lib/tls/i686/cmov/libc.so.6
#1  0xb7d784cb in scanf () from /lib/tls/i686/cmov/libc.so.6
#2  0x080484b4 in main () at sample1.cpp:7

L'erreur vient donc de l'appel à scanf fait depuis la ligne 7. Et en effet, Buffer n'est pas alloué et pointe sur n'importe quoi. On peut simplement recompiler après avoir corrigé, mais on peut aussi vérifier que l'erreur vient bien de là :

(gdb) start
Breakpoint 1 at 0x8048495: file sample1.cpp, line 6.
Starting program: /home/dhkold/Documents/code/gdb/main
main () at sample1.cpp:6
6           printf("Nom? ");
(gdb) set var Buffer = malloc(50)
(gdb) print Buffer
$1 = 0x804a008 ""
(gdb) c
Continuing.
Nom? DHKold
 
Program exited normally.

Et voilà, c'est donc bien Buffer qui pose problème, et il suffit de l'allouer pour ne plus avoir d'erreur. J'espère que ce tout petit exemple vous a permis de voir comment utiliser les commandes GDB que nous avons étudiées durant ce tutoriel. N'hésitez pas à aller lire la documentation sur le site de GDB, elle est en anglais et n'est pas toujours très claire, mais si vous connaissez déjà les bases vous devriez pouvoir vous y retrouver.

Voilà qui est fait, vous devriez maintenant être capables de vous servir de GDB correctement.