More gdb python

Author: cirosantilli

README.md

@@ -28,7 +28,9 @@ Relies on [C++ boilerplate](https://github.com/cirosantilli/cpp-boilerplate) to
     1.  [gprof](gprof.md)
     1.  [Valgrind](valgrind.md)
     1.  [perf](perf.md)
-1.  [GDB](gdb/)
+1.  Analysis tools
+    1.  [GDB](gdb/)
+    1.  [cflow](cflow.md)
 1.  [Boost](boost/)
 1.  [CMake](cmake.md)
 1.  [Flex and Bison](flex-bison/)

c/extern/Makefile

@@ -1 +1 @@
-../c_one.makefile
+../../c_one.makefile

c/implementations.md

@@ -75,7 +75,7 @@ Then there are several implementations that target Linux-only embedded systems,
 - musl libc. Comparison: <http://www.etalabs.net/compare_libcs.html>. Alpine Linux moved to it, as it is partially binary compatible with glibc.
 - Bionic (Android): <https://en.wikipedia.org/wiki/Bionic_%28software%29>
 - dietlibc <http://www.fefe.de/dietlibc/>
-- newlibc <https://en.wikipedia.org/wiki/Newlib>
+- newlibc <https://en.wikipedia.org/wiki/Newlib>. GNU.
 
 ### ulibc
 

c/operator.c

@@ -592,7 +592,14 @@ int main() {
         assert((i &= (char)0x00) == (char)0x00);
         assert((char)i == (char)0x00);
 
-        /* same others bitwise, except ~= */
+        /* Same for others bitwise, except ~= which does not exist. */
+        {
+            unsigned char i = 0xFF;
+            i = ~i;
+            /* ? */
+            /*i~=;*/
+            assert((i & 0xFF) == 0);
+        }
     }
 
     /*

c_one.makefile

@@ -12,7 +12,7 @@ LIBS ?= -lm
 OUT_EXT ?= .out
 RUN ?= main
 TEST ?= test
-TMP_EXT ?= .tmp
+TMP_EXT ?= .o
 
 INS := $(wildcard *$(IN_EXT))
 OUTS_NOEXT := $(basename $(INS))

cflow.md

@@ -0,0 +1,23 @@
+# cflow
+
+Make static call graphs.
+
+GNU.
+
+<https://en.wikipedia.org/wiki/GNU_cflow>
+
+<http://www.gnu.org/software/cflow/>
+
+Usage:
+
+    cflow main.c
+
+Sample output:
+
+    main() <int main () at main.c:49>:
+        printA()
+        printMain() <void printMain () at main.c:40>:
+            printf()
+        printf()
+
+TODO C++ method? Does not seem to work.

gdb/README.md

@@ -7,24 +7,33 @@ GNU debugger.
 1.  [Invocation](invocation.md)
 1.  [Commands](commands.md)
 1.  Examples
-    1. [run](run)
-    1. [nested.c](nested.c)
-    1. [count_infinite.c](count_infinite.c)
-    1. [big_function.c](big_function.c)
-    1. [String](string.c)
-    1. [C++ function overload](overload.cpp)
-    1. [Segmentation Fault](segv.c)
+    1.  [run](run)
+    1.  [nested.c](nested.c)
+    1.  [count_infinite.c](count_infinite.c)
+    1.  [big_function.c](big_function.c)
+    1.  [String](string.c)
+    1.  [C++ function overload](overload.cpp)
+    1.  [Segmentation Fault](segv.c)
+    1.  [Multifile](multifile/)
 1.  GDB scripts
-    1. [step_all](step_all.gdb)
-    1. [si_all](si_all.gdb)
+    1.  [step_all](step_all.gdb)
+    1.  [si_all](si_all.gdb)
 1.  [Python interface](python-interface.md)
-    [Multiple Python invocations](multiple_python_invocations)
-    [help.py](help.py)
-    [hello_world.py](hello_world.py)
-    [Visible variables](visible-variables.py)
-    [Block, Symbol](block.py)
-    [print_lines.py](print_lines.py)
-    [Value](value.py)
-    [read_var()](read_var.py)
-    [argv-wrapper](argv-wrapper)
+    1.  [Multiple Python invocations](multiple_python_invocations)
+    1.  [help.py](help.py)
+    1.  [hello_world.py](hello_world.py)
+    1.  [Visible variables](visible-variables.py)
+        1.  [Globals](globals.py)
+    1.  [Block, Symbol](block.py)
+    1.  [print_lines.py](print_lines.py)
+    1.  [Value](value.py)
+    1.  [read_var()](read_var.py)
+    1.  [Command](command)
+    1.  [argv-wrapper](argv-wrapper)
+    1.  [Call graph](call_graph_rbreak.py)
+    1.  [Continue until instruction](continue_instruction.py)
+        1.  [Continue until return](continue_return.py)
+    1.  [Break on return](break_return.py)
+    1.  [Disassemble minimal example](disassemble.py)
+        1.  [disas](disas.py)
 1.  [Internals](internals.md)

gdb/break_return.py

@@ -0,0 +1,39 @@
+"""
+## Break return
+
+Add a breakpoint to every return instruction of the current function.
+
+http://stackoverflow.com/questions/3649468/setting-breakpoint-in-gdb-where-the-function-returns
+"""
+
+class BreakReturn(gdb.Command):
+    def __init__(self):
+        super().__init__(
+            'break-return',
+            gdb.COMMAND_RUNNING,
+            gdb.COMPLETE_NONE,
+            False
+        )
+    def invoke(self, arg, from_tty):
+        frame = gdb.selected_frame()
+        block = frame.block()
+        while block:
+            if block.function:
+                break
+        start = block.start
+        end = block.end
+        arch = frame.architecture()
+        pc = gdb.selected_frame().pc()
+        instructions = arch.disassemble(start, end - 1)
+        for instruction in instructions:
+            if instruction['asm'].startswith('retq '):
+                gdb.Breakpoint('*{}'.format(instruction['addr']))
+BreakReturn()
+
+gdb.execute('file continue_return_py.out', to_string=True)
+gdb.execute('start', to_string=True)
+gdb.execute('disas')
+print()
+gdb.execute('break-return')
+gdb.execute('continue')
+gdb.execute('disas')

gdb/call_graph.py

@@ -0,0 +1,67 @@
+"""
+## Call graph
+
+This implementation disassembles every function it stops at,
+and adds a breakpoint at the functions it calls.
+
+This is slower runtime than initial `rbreak .`,
+but typically faster as we move locally.
+
+- http://stackoverflow.com/questions/9549693/gdb-list-of-all-function-calls-made-in-an-application
+- http://stackoverflow.com/questions/311948/make-gdb-print-control-flow-of-functions-as-they-are-called
+"""
+
+gdb.execute('file call_graph_py.out', to_string=True)
+# rbreak before start to ignore dynamically linked stdlib functions.
+gdb.execute('set confirm off')
+gdb.execute('start', to_string=True)
+depth_string = 4 * ' '
+thread = gdb.inferiors()[0].threads()[0]
+while thread.is_valid():
+    frame = gdb.selected_frame()
+    symtab = frame.find_sal().symtab
+
+    stack_depth = 0
+    f = frame
+    while f:
+        stack_depth += 1
+        f = f.older()
+
+    # Not present for files without debug symbols.
+    source_path = '???'
+    if symtab:
+        #source_path = symtab.fullname()
+        source_path = symtab.filename
+
+    # Not present for files without debug symbols.
+    args = '???'
+    block = None
+    try:
+        block = frame.block()
+    except:
+        pass
+    if block:
+        args = ''
+        for symbol in block:
+            if symbol.is_argument:
+                args += '{} = {}, '.format(symbol.name, symbol.value(frame))
+
+        # Mark new breakpoints.
+        while block:
+            if block.function:
+                break
+        start = block.start
+        end = block.end
+        arch = frame.architecture()
+        pc = gdb.selected_frame().pc()
+        instructions = arch.disassemble(start, end - 1)
+        for instruction in instructions:
+            print('{:x} {}'.format(instruction['addr'], instruction['asm']))
+
+    print('{}{} : {} : {}'.format(
+        stack_depth * depth_string,
+        source_path,
+        frame.name(),
+        args
+    ))
+    gdb.execute('continue', to_string=True)

gdb/call_graph_py.c

@@ -0,0 +1,36 @@
+/*
+Stack trace tests: bt, f, whe
+*/
+
+#include <stdio.h>
+
+int f0_0_0(int i) {
+    return i + 3;
+}
+
+int f0_0_1(int i) {
+    return i + 2;
+}
+
+int f0_1(int i) {
+    return i + 1;
+}
+
+int f0_0(int i) {
+    i += f0_0_0(i);
+    i += f0_0_1(i);
+    i += f0_0_0(i);
+    return i;
+}
+
+int f0(int i) {
+    i += f0_0(i);
+    i += f0_0(i);
+    i += f0_1(i);
+    return i;
+}
+
+int main() {
+    printf("%d\n", f0(1));
+    return 0;
+}

gdb/call_graph_rbreak.py

@@ -0,0 +1,55 @@
+"""
+## Call graph rbreak
+
+Build a function call graph of the non-dynamic functions of an executable.
+
+This implementation is very slow for very large projects, where `rbreak .` takes forever to complete.
+
+- http://stackoverflow.com/questions/9549693/gdb-list-of-all-function-calls-made-in-an-application
+- http://stackoverflow.com/questions/311948/make-gdb-print-control-flow-of-functions-as-they-are-called
+"""
+
+gdb.execute('file cc1', to_string=True)
+gdb.execute('rbreak .', to_string=True)
+gdb.execute('set args hello_world.c', to_string=True)
+# rbreak before start to ignore dynamically linked stdlib functions.
+gdb.execute('set confirm off')
+gdb.execute('start', to_string=True)
+depth_string = 4 * ' '
+thread = gdb.inferiors()[0].threads()[0]
+while thread.is_valid():
+    frame = gdb.selected_frame()
+    symtab = frame.find_sal().symtab
+
+    stack_depth = 0
+    f = frame
+    while f:
+        stack_depth += 1
+        f = f.older()
+
+    # Not present for files without debug symbols.
+    source_path = '???'
+    if symtab:
+        #source_path = symtab.fullname()
+        source_path = symtab.filename
+
+    # Not present for files without debug symbols.
+    args = '???'
+    block = None
+    try:
+        block = frame.block()
+    except:
+        pass
+    if block:
+        args = ''
+        for symbol in block:
+            if symbol.is_argument:
+                args += '{} = {}, '.format(symbol.name, symbol.value(frame))
+
+    print('{}{} : {} : {}'.format(
+        stack_depth * depth_string,
+        source_path,
+        frame.name(),
+        args
+    ))
+    gdb.execute('continue', to_string=True)

gdb/command.py

@@ -1,21 +1,26 @@
 """
 Define a new GDB command with Python.
+
+https://sourceware.org/gdb/onlinedocs/gdb/Commands-In-Python.html
 """
 
-class NewCmd (gdb.Command):
-    "newcmd docstring."
-    def __init__ (self):
+class NewCmd(gdb.Command):
+    # Will appear on help newcmd.
+    "docstring"
+    def __init__(self):
         super().__init__(
-            'newcmd',
-            gdb.COMMAND_SUPPORT,
-            gdb.COMPLETE_NONE,
-            True
+            'newcmd',          # Name.
+            gdb.COMMAND_NONE,  # Category when `help` is entered.
+            gdb.COMPLETE_NONE, # No autocomplete.
+            False              # Take subcommand?
         )
     def invoke(self, arg, from_tty):
         print('newcmd')
-        print('arg = ' + str(arg))
+        assert type(arg) is str
+        print('arg = ' + arg)
         print('from_tty = ' + str(from_tty))
+# This already registers it.
 NewCmd()
 gdb.execute('help newcmd')
-gdb.execute('newcmd')
+print()
 gdb.execute('newcmd a b')