gdb rbreak_directory

Author: cirosantilli

c/function_pointer.c

@@ -31,9 +31,9 @@ int main() {
     {
         int (*f)(int, int);
         f = add_int;
-        assert((*f)(1, 2) == 3);
+        assert(f(1, 2) == 3);
         f = sub_int;
-        assert((*f)(1, 2) == -1);
+        assert(f(1, 2) == -1);
     }
 
     /* We can also add argument names if we are on a verbose mood. */
@@ -56,14 +56,15 @@ int main() {
     */
     {
         int (*fs[])(int, int) = {add_int, sub_int};
-        assert((*fs[0])(1, 2) ==  3);
-        assert((*fs[1])(1, 2) == -1);
+        assert(fs[0](1, 2) ==  3);
+        assert(fs[1](1, 2) == -1);
     }
 
     /*
     There are multiple ways to initialize and use function pointers because of implicit conversions.
 
-    http://stackoverflow.com/questions/6893285/why-do-function-pointer-definitions-work-with-any-number-of-ampersands-or-as
+    - http://stackoverflow.com/questions/6893285/why-do-function-pointer-definitions-work-with-any-number-of-ampersands-or-as
+    - http://stackoverflow.com/questions/23960436/is-the-asterisk-optional-when-calling-a-function-pointer
     */
     {
         /* Alternative initialization methods. */
@@ -84,7 +85,7 @@ int main() {
 
         /* ERROR no alternative for the declaration. */
         {
-            /*int (f)(int n, int m) = add_int;*/
+            /*int f(int n, int m) = add_int;*/
         }
     }
 

c/struct.c

@@ -338,11 +338,6 @@ int main() {
         It is possible to create structs which don't have a name.
 
         Only the structs declared immediatiely after definition can be used.
-
-        In theory only standardized in C11, but I am yet to be able to make GCC generate a warning.
-        even with `-std=89 -pedantic -Wall`.
-
-        http://stackoverflow.com/questions/14248044/are-anonymous-structs-standard-and-really-what-are-they
     */
     {
         /* Basic. */
@@ -415,6 +410,13 @@ int main() {
     /*
     # typedef struct combo
 
+        TL;DR best practice: whenever possible use:
+
+            typedef struct {} S;
+
+        Some people, notably the Linux kernel, disagree:
+        http://stackoverflow.com/questions/252780/why-should-we-typedef-a-struct-so-often-in-c
+
         Advantages:
 
         -   avoid typing struct all over
@@ -430,10 +432,6 @@ int main() {
         -   put all declaration information into one single place.
             No more "Should the typedef be before or after?" doubts.
 
-        TL;DR best practice: whenever possible use:
-
-            typedef struct {} S;
-
         Unfortunately this cannot be done if you need to declare the struct elsewhere to:
 
         -   you use a pointer to a struct of the same type inside it.
@@ -487,9 +485,7 @@ int main() {
         /*
         The typedef and the struct can have the same name.
 
-        So the common C89 pattern is `typedef struct S {...} S`.
-
-        C11 adds anonymous structs which is even better.
+        A common C89 pattern is `typedef struct S {...} S`.
         */
         {
             typedef struct S {

c_one.makefile

@@ -34,9 +34,11 @@ Tested on 7.7.1 unless mentioned otherwise.
     1.  [argv-wrapper](argv-wrapper)
     1.  [Call graph](call_graph.py)
         1.  [Call graph rbreak](call_graph_rbreak.py)
+        1.  [Call graph walk filter](call_graph_walk_filter.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.  [rbreak_directory.py](rbreak_directory.py)
 1.  [Internals](internals.md)

gdb/README.md

@@ -5,7 +5,7 @@
 and adds a breakpoint at the functions it calls.
 
 This is slower runtime than initial `rbreak .`,
-but typically faster as we move locally.
+but typically faster for large code bases as it avoids the huge initial rbreak overhead.
 
 - 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/call_graph.py renamed to gdb/call_graph_walk.py

@@ -0,0 +1,104 @@
+"""
+## Call graph walk
+
+TODO this is currenty broken. I half gave up on it when I noticed that
+the bottleneck was filtering functions by directory, which is harder on this walk implementation
+because we have to break at the callq instructions.
+I'm keeping this file as some of the walking code might be reused.
+
+This implementation disassembles every function it stops at,
+and adds a breakpoint at the functions callq commands.
+
+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
+"""
+
+import re
+
+path_filter_re = re.compile(r'/gcc/')
+
+gdb.execute('file cc1', to_string=True)
+gdb.execute('set args hello_world.c', to_string=True)
+gdb.execute('start', to_string=True)
+depth_string = 4 * ' '
+thread = gdb.inferiors()[0].threads()[0]
+# Function addresses that have already been disassembled.
+disassembled_functions = set()
+# Function addresses whose path does not match the filter regex.
+function_blacklist = set()
+while True:
+    path_filter_re_matches = path_filter_re.search(source_path)
+    frame = gdb.selected_frame()
+
+    if not path_filter_re_matches:
+        pass
+        # TODO
+
+    stack_depth = 0
+    f = frame
+    while f:
+        stack_depth += 1
+        f = f.older()
+
+    # Not present for files without debug symbols.
+    source_path = '???'
+    symtab = frame.find_sal().symtab
+    if symtab:
+        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))
+
+        if path_filter_re_matches:
+            # Put a breakpoint on the address of every funtion called from this function.
+            # Only do that the first time we enter a function (TODO implement.)
+            start = block.start
+            if not start in disassembled_functions:
+                disassembled_functions.add(start)
+                end = block.end
+                arch = frame.architecture()
+                pc = gdb.selected_frame().pc()
+                instructions = arch.disassemble(start, end - 1)
+                for instruction in instructions:
+                    # This is UGLY. I wish there was a disassembly Python interface to GDB,
+                    # like https://github.com/aquynh/capstone which allows to extract
+                    # the opcode without parsing.
+                    instruction_parts = instruction['asm'].split()
+                    opcode = instruction_parts[0]
+                    if opcode == 'callq':
+                        # fails for instructions that start with *, basically rip (could be resolved to an address statically)
+                        # or rax (must be broken upon every time since we don't know where it will jump to).
+                        try:
+                            target_address = int(instruction_parts[1][2:], 16)
+                        except ValueError:
+                            target_address = None
+                        if not (target_address and target_address in function_blacklist):
+                            gdb.Breakpoint('*{}'.format(instruction['addr']), internal=True)
+
+    print('{}{} : {} : {}'.format(
+        stack_depth * depth_string,
+        source_path,
+        frame.name(),
+        args
+    ))
+
+    # We are at the call instruction.
+    gdb.execute('continue', to_string=True)
+    if thread.is_valid():
+        # We are at the first instruction of the called function.
+        gdb.execute('stepi', to_string=True)
+    else:
+        break

gdb/call_graph_walk_filter.py

@@ -15,12 +15,16 @@ def __init__(self):
             False              # Take subcommand?
         )
     def invoke(self, arg, from_tty):
+        """
+        Everything printed here to stdout is captured by `execute to_string=True`.
+        """
         print('newcmd')
         assert type(arg) is str
         print('arg = ' + arg)
         print('from_tty = ' + str(from_tty))
 # This already registers it.
 NewCmd()
+
 gdb.execute('help newcmd')
 print()
 gdb.execute('newcmd a b')

gdb/command.py

@@ -0,0 +1,36 @@
+.POSIX:
+
+-include params.makefile
+
+DIRS ?= . d e
+G ?= gdb3
+O ?= 0
+STD ?= c11
+CCC ?= gcc
+CCFLAGS ?= -DIMPLEMENTATION_SIGNAL -DUNDEFINED_BEHAVIOUR -g$(G) -pedantic-errors -std=$(STD) -O$(O) -Wextra -Wno-ignored-qualifiers -Wno-sign-compare -Wno-unused-variable -Wno-unused-label -Wno-unused-but-set-variable
+IN_EXT ?= .c
+LIBS ?= -lm
+OUT_EXT ?= .out
+RUN ?= main
+TEST ?= test
+TMP_EXT ?= .o
+
+INS := $(foreach DIR,$(DIRS),$(wildcard $(DIR)/*$(IN_EXT)))
+OUTS_NOEXT := $(basename $(INS))
+OUTS := $(addsuffix $(TMP_EXT), $(OUTS_NOEXT))
+RUN_BASENAME := $(RUN)$(OUT_EXT)
+
+.PHONY: clean run
+
+$(RUN_BASENAME): $(OUTS)
+	$(CCC) $(CCFLAGS) -o '$@' $+ $(LIBS)
+
+%$(TMP_EXT): %$(IN_EXT)
+	$(CCC) $(CCFLAGS) -c '$<' -o '$@' $(LIBS)
+
+clean:
+	for d in $(DIRS); do rm -f "$$d"/*'$(TMP_EXT)'; done
+	rm -f '$(RUN_BASENAME)'
+
+run: $(RUN_BASENAME)
+	./'$(RUN_BASENAME)'

gdb/multifile/Makefile

@@ -1,3 +1,3 @@
 # Multifile
 
-Test GDB with multiple source files.
+Test GDB with multiple source files and multiple directories.

gdb/multifile/Makefile

@@ -1 +1,3 @@
-int a = 1;
+int a_i = 1;
+int a_f() { return 1; }
+int a_g() { return 1; }

gdb/multifile/README.md

@@ -0,0 +1,3 @@
+int d_a_i = 1;
+int d_a_f() { return 1; }
+int d_a_g() { return 1; }

gdb/multifile/a.c

@@ -0,0 +1,3 @@
+int d_b_i = 1;
+int d_b_f() { return 1; }
+int d_b_g() { return 1; }

gdb/multifile/d/a.c

@@ -0,0 +1,3 @@
+int e_a_i = 1;
+int e_a_f() { return 1; }
+int e_a_g() { return 1; }

gdb/multifile/d/b.c

@@ -1,9 +1,27 @@
 #include <assert.h>
 
-int i;
-extern int a;
+extern int a_i, d_a_i, d_b_i, e_a_i;
+int a_f(), d_a_f(), e_a_f();
+int a_g(), d_a_g(), e_a_g();
+int        d_b_f();
+int        d_b_g();
+
+int main_a = 1;
+int main_f() { return 1; }
+int main_g() { return 1; }
 
 int main() {
-    assert(a == 1);
+    assert(main_a == 1);
+    assert(main_f() == 1);
+    assert(main_g() == 1);
+    assert(d_a_i == 1);
+    assert(d_a_f() == 1);
+    assert(d_a_g() == 1);
+    assert(d_b_i == 1);
+    assert(d_b_f() == 1);
+    assert(d_b_g() == 1);
+    assert(e_a_i == 1);
+    assert(e_a_f() == 1);
+    assert(e_a_g() == 1);
     return 0;
 }

gdb/multifile/e/a.c

@@ -0,0 +1,28 @@
+"""
+## rbreak all files in a directory
+
+This method is dirty because it uses the gdb-only command to do the job, but works.
+
+http://stackoverflow.com/questions/29437138/can-gdb-set-break-at-every-function-inside-a-directory
+"""
+
+import os
+
+class RbreakDir(gdb.Command):
+    def __init__(self):
+        super().__init__(
+            'rbreak-dir',
+            gdb.COMMAND_BREAKPOINTS,
+            gdb.COMPLETE_NONE,
+            False
+        )
+    def invoke(self, arg, from_tty):
+        for root, dirs, files in os.walk(arg):
+            for basename in files:
+                path = os.path.join(root, basename)
+                gdb.execute('rbreak {}:.'.format(path), to_string=True)
+RbreakDir()
+
+gdb.execute('file multifile/main.out', to_string=True)
+gdb.execute('rbreak-dir multifile/d')
+gdb.execute('info breakpoints')