Autonomous Debugging with IBM BOB

Overview

The Compiler Copilot includes an Autonomous Debugging feature where IBM BOB takes complete control of the debugging session. Instead of manually entering debugging commands, you simply specify your debugging goal, and BOB automatically:

Runs appropriate debugging commands
Analyzes the output from each command
Decides the next debugging step based on findings
Continues until the goal is achieved or maximum steps reached
Generates a comprehensive summary of findings

This enables hands-off debugging where you can focus on understanding the results rather than executing individual commands.

How It Works

Architecture

User Input (Goal)
       ↓
IBM BOB Analyzes Goal
       ↓
┌──────────────────────────────────┐
│  Autonomous Debugging Loop       │
│                                  │
│  1. BOB decides next command     │
│  2. Execute command in debugger  │
│  3. BOB analyzes output          │
│  4. Check if goal achieved       │
│  5. Repeat or complete           │
└──────────────────────────────────┘
       ↓
Generate Summary
       ↓
Present Findings to User

Decision Making Process

IBM BOB uses the following strategy to decide debugging commands:

Initial Phase: Start with basic commands (run, backtrace, info registers)
Investigation Phase: Set breakpoints, examine variables, inspect memory
Analysis Phase: Step through code, analyze stack traces, check register values
Completion Phase: Determine if goal is achieved or if stuck

Usage

Basic Command

autodebug <program> "<debugging_goal>" [--debugger gdb|lldb]

Examples

Example 1: Find Segmentation Fault

copilot> autodebug ./myprogram "Find cause of segmentation fault"

What BOB Does:

Starts the program
Runs until crash
Gets backtrace
Examines registers at crash point
Inspects memory addresses
Identifies null pointer dereference
Provides fix suggestions

Example 2: Debug Memory Leak

copilot> autodebug ./app "Identify memory leak" --debugger gdb

What BOB Does:

Sets breakpoints at malloc/free
Runs program
Tracks allocations
Identifies unfreed memory
Shows allocation stack traces
Suggests where to add free()

Example 3: Infinite Loop

copilot> autodebug ./test "Debug infinite loop"

What BOB Does:

Runs program
Interrupts after timeout
Gets backtrace
Examines loop variables
Identifies loop condition issue
Suggests fix

Example 4: Logic Error

copilot> autodebug ./calculator "Find why division returns wrong result"

What BOB Does:

Sets breakpoint at division function
Runs with test input
Steps through function
Examines variables at each step
Identifies integer division issue
Suggests using float

Session Output

Real-time Output

During autonomous debugging, you'll see:

🤖 AUTONOMOUS DEBUGGING SESSION STARTED
================================================================================
Session ID: debug_1717567890
Program: ./myprogram
Goal: Find cause of segmentation fault
Debugger: GDB
Max Steps: 50
================================================================================

────────────────────────────────────────────────────────────────────────────────
🔍 Step 1/50
────────────────────────────────────────────────────────────────────────────────
💭 BOB's reasoning: Start program execution to trigger the crash
🔧 Executing: run
📤 Output:
Starting program: /path/to/myprogram
Program received signal SIGSEGV, Segmentation fault.
0x0000000000401234 in main () at program.c:15
15          *ptr = 42;
🧠 BOB's analysis: Program crashed with SIGSEGV at line 15 when dereferencing pointer 'ptr'

────────────────────────────────────────────────────────────────────────────────
🔍 Step 2/50
────────────────────────────────────────────────────────────────────────────────
💭 BOB's reasoning: Get full stack trace to understand call chain
🔧 Executing: backtrace
📤 Output:
#0  0x0000000000401234 in main () at program.c:15
🧠 BOB's analysis: Crash occurred in main function, no other functions in call stack

... (continues until goal achieved)

✅ BOB determined debugging goal is achieved

================================================================================
📊 GENERATING DEBUGGING SUMMARY
================================================================================

================================================================================
📋 AUTONOMOUS DEBUGGING SESSION SUMMARY
================================================================================

Session ID: debug_1717567890
Program: ./myprogram
Goal: Find cause of segmentation fault
Total Steps: 5
Duration: 0m 12s

## OBJECTIVE
Find the root cause of the segmentation fault in the program.

## APPROACH
1. Executed the program to trigger the crash
2. Analyzed the crash location and stack trace
3. Examined the pointer variable that caused the crash
4. Inspected memory and register values
5. Identified the null pointer dereference

## KEY FINDINGS
- Segmentation fault at line 15 in main()
- Pointer 'ptr' was NULL when dereferenced
- No initialization of 'ptr' before use
- Register analysis confirms NULL pointer (0x0)

## TECHNICAL DETAILS
- Crash address: 0x0000000000401234
- Faulting instruction: mov DWORD PTR [rax], 0x2a
- RAX register: 0x0 (NULL)
- Source line: *ptr = 42;

## CONCLUSION
The segmentation fault is caused by dereferencing an uninitialized pointer 'ptr'
at line 15. The pointer was never assigned a valid memory address before use.

## RECOMMENDATIONS
1. Initialize ptr before use: int *ptr = malloc(sizeof(int));
2. Add NULL check: if (ptr != NULL) { *ptr = 42; }
3. Free allocated memory: free(ptr);
4. Compile with warnings: gcc -Wall -Wextra program.c

================================================================================

💾 Session saved to: /path/to/sessions/autodebug_debug_1717567890.json

Session File

The complete session is saved as JSON:

{
  "session_id": "debug_1717567890",
  "program": "./myprogram",
  "debugger_type": "gdb",
  "initial_goal": "Find cause of segmentation fault",
  "start_time": "2026-06-05T12:00:00",
  "end_time": "2026-06-05T12:00:12",
  "total_steps": 5,
  "findings": [
    "Segmentation fault at line 15",
    "NULL pointer dereference identified",
    "Pointer 'ptr' was never initialized"
  ],
  "summary": "...",
  "steps": [
    {
      "step_number": 1,
      "command": "run",
      "output": "...",
      "analysis": "...",
      "timestamp": "2026-06-05T12:00:01"
    }
    // ... more steps
  ]
}

Configuration

Maximum Steps

By default, autonomous debugging runs for a maximum of 50 steps. This prevents infinite loops. You can modify this in the code:

auto_debugger = AutonomousDebugger(
    debugger_wrapper=debugger_wrapper,
    llm_client=self.ibm_bob,
    max_steps=100  # Increase if needed
)

Debugger Selection

Choose between GDB and LLDB:

# Use GDB (default)
autodebug ./program "goal"

# Use LLDB explicitly
autodebug ./program "goal" --debugger lldb

# Use GDB explicitly
autodebug ./program "goal" --debugger gdb

Best Practices

1. Clear Goals

Provide specific, actionable goals:

✅ Good:

"Find cause of segmentation fault"
"Identify memory leak in function process_data"
"Debug why loop never terminates"
"Find why variable x has wrong value"

❌ Bad:

"Fix my program"
"Make it work"
"Debug"

2. Compile with Debug Info

Always compile with -g flag:

gcc -g -O0 program.c -o program

This provides:

Line number information
Variable names
Function names
Source code mapping

3. Reproducible Issues

Ensure the issue is reproducible:

Use consistent input
Set random seeds if applicable
Document steps to trigger the issue

4. Review Sessions

After autonomous debugging:

Read the summary carefully
Review the session JSON for details
Understand each step BOB took
Apply suggested fixes
Re-run to verify

Comparison: Manual vs Autonomous

Manual Debugging

copilot> debug ./program
copilot> run
copilot> backtrace
copilot> info registers
copilot> print ptr
copilot> x/10x ptr
# ... many more commands

Pros:

Full control
Can explore freely
Learn debugging techniques

Cons:

Time-consuming
Requires debugging expertise
Easy to miss important details