How to print the whole linked list in gdb?

When using GDB (GNU Debugger) for debugging programs, if you want to print the contents of the entire linked list, there are multiple approaches available. Here is a general method: by writing a small script to iterate through the linked list and print detailed information for each node.

First, we assume the node definition is as follows:

c
typedef struct Node {
    int data;
    struct Node* next;
} Node;

The head node of the linked list is head.

Steps to Print the Entire Linked List

1. Set a breakpoint: First, set a breakpoint at an appropriate location to ensure the linked list is fully constructed. For example, if the linked list construction completes at a specific point in the main() function, set the breakpoint there.

   gdb
   (gdb) break main
   (gdb) run

2. Use GDB's Python extension: GDB provides a Python API that enables you to extend its functionality with Python scripts. You can write a script to traverse the linked list.

   python
   class ListNodePrinter(gdb.Command):
       "A command to print linked lists."
   
       def __init__(self):
           super(ListNodePrinter, self).__init__("print-list", gdb.COMMAND_DATA)
   
       def invoke(self, arg, from_tty):
           node = gdb.parse_and_eval(arg)
           while node != 0:
               print("Node data: %d" % node['data'])
               node = node['next']
   
   ListNodePrinter()

   Copy the above Python script into the GDB session or save it to a file and load it using the source command.

3. Invoke the custom command: Once defined, use it to print the entire linked list.

   gdb
   (gdb) print-list head

   This will sequentially print the value of the data field for each node in the linked list.

Practical Example

Assume we have a simple program that constructs and traverses a linked list:

c
#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* create_node(int data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}

int main() {
    Node* head = create_node(1);
    head->next = create_node(2);
    head->next->next = create_node(3);

    // Assume a breakpoint is set here
    return 0;
}

In this example, set a breakpoint before return 0; and then use the previously defined print-list command in GDB to print the entire linked list.

The advantage of this method is that it can be applied to any linked list type with minor modifications for different node structures. Additionally, using Python scripts allows you to easily customize output formats or implement more complex traversal logic as needed. This flexibility is highly valuable when working with complex data structures.