GDB passo em atrasos

A CLI do Gdb suporta um whileloop. Não há nenhum comando embutido sleep, mas você pode chamar o shell para executar o sleepprograma ou usar o interpretador python embutido do gdb, se tiver um. É interrompível com Control-C.

Método 1:

(gdb) while (1) 
 > passo 
 > shell sleep 1 
 > fim

Método 2:

(gdb) python import time 
(gdb) while (1) 
 > step 
 > python time.sleep(1) 
 > end

Método 3 (definir uma macro):

(gdb) define runlowly
Digite os comandos para a definição de "runslowly".
Termine com uma linha dizendo apenas "fim".
> python import time 
> while (1) 
 > step 
 > python time.sleep(1) 
 > end 
> end 
(gdb) document runslowly
Digite a documentação para "runslowly".
Termine com uma linha dizendo apenas "fim".
> passo uma linha de cada vez, a cada 1 segundo 
> fim

(gdb) roda lentamente

expectpode automatizar isso

#!/usr/bin/env expect
spawn -noecho gdb -q ls
expect -ex {(gdb)}
send -- "break main\r"
expect -ex {(gdb)}
send -- "run\r"
while {1} {
    expect -ex {(gdb)}
    send -- "s\r"
    sleep 1
}

ou se houver risco do programa ficar sem svocê pode repeti gdb-lo com um pouco mais de complicação

#!/usr/bin/env expect

while {1} {
    spawn -noecho gdb -q ls
    expect -ex {(gdb)}
    send -- "break main\r"
    expect -ex {(gdb)}
    send -- "run\r"
    expect {
        -ex {The program is not being run} {}
        eof {}
        -ex {(gdb)} {
            send -- "s\r"
            sleep 1
            exp_continue
        }
    }
}

Você pode ter o shell pipe em comandos; aqui fica a ideia:

while :; do echo step; sleep 1; done | gdb arm-program

gdb lê os comandos do pipe; ele vê um comando "step" a cada segundo ad infinitum.

Você pode querer configurar alguns pontos de interrupção e executar o programa; ajuste a gosto:

(echo br 1; echo run; while :; do echo step; sleep 1; done ) | gdb arm-program

A resposta atualmente aceita sempre step , uma vez iniciada e, portanto, também "pula" pontos de interrupção, sinais e até mesmo o final do programa (no último caso, gerando um único erro "O programa não está sendo executado" antes de o gdb abortar internamente o whilelocal onde isso aconteceu) .
Como um culpado adicional, ele para se a paginação estiver ativada (que é o padrão) assim que a saída do GDB estiver "cheia".

Usando a API python, isso pode ser tratado de maneira agradável:

• definir um comando de usuário (com argumento adicional para dizer o quão rápido deve ser feito automaticamente)
• opcional: defina um parâmetro para o padrão (substituído aqui para simplificar por um valor fixo)
• faça o loop while dentro do python, manipule a interrupção de teclado "esperada" de CTRL-C
• registre um stopmanipulador de eventos que verifique o motivo da parada e armazene o tipo de etapa lá
• ajuste o loop while para parar para uma parada "não simples" (breakpoint/watchpoint/signal/...)

O seguinte código pode ser colocado em um gdb-auto-step.py que pode ser ativado source gdb-auto-step.pyquando você quiser (ou incluir no arquivo .gdbinit para torná-lo sempre disponível):

import gdb
import time

class CmdAutoStep (gdb.Command):
    """Auto-Step through the code until something happens or manually interrupted.
An argument says how fast auto stepping is done (1-19, default 5)."""
    def __init__(self):
        print('Registering command auto-step')
        super(CmdAutoStep, self).__init__("auto-step", gdb.COMMAND_RUNNING)
        gdb.events.stop.connect(stop_handler_auto_step)

    def invoke(self, argument, from_tty):

        try:
            frame = gdb.newest_frame()
        except gdb.error:
            raise gdb.GdbError("The program is not being run.")

        number = 5 # optional: use a parameter for the default
        if argument:
            if not argument.isdigit():
                raise gdb.GdbError("argument must be a digit, not " + argument)
            number = int(argument)
            if number == 0 or number > 19:
                raise gdb.GdbError("argument must be a digit between 1 and 19")

        sleep_time = 3.0 / (number * 1.4)

        global last_stop_was_simple
        last_stop_was_simple = True

        pagination = gdb.execute("show pagination", False, True).find("on")
        if pagination:
            gdb.execute("set pagination off", False, False)
        
        try:
            while (last_stop_was_simple):
                gdb.execute ("step")
                time.sleep(sleep_time)
        except KeyboardInterrupt as ki:
            if pagination:
                gdb.execute("set pagination on", False, False)
        except gdb.GdbError as user_error:
            if pagination:
                gdb.execute("set pagination on", False, False)
            # pass user errors unchanged
            raise user_error
        except:
            if pagination:
                gdb.execute("set pagination on", False, False)
            traceback.print_exc()

def stop_handler_auto_step(event):
    # check the type of stop, the following is the common one after step/next,
    # a more complex one would be a subclass (for example breakpoint or signal)
    global last_stop_was_simple
    last_stop_was_simple = type(event) is gdb.StopEvent

CmdAutoStep()