# Repeat Commands

In LLDB's command line interface, pressing Enter (an empty command) repeats the
previous command. By default, the exact same command is re-executed. However,
several commands customize this behavior to implement paging or progressive
expansion, making it easy to explore data incrementally by pressing Enter
repeatedly. Repeat commands can be learned and discovered by pressing enter and
observing the result.

In some instances, commands disable repeat commands, to prevent
accidentally triggering a destructive operation (e.g. `process launch`).

This page documents the commands with custom repeat behavior.

## `thread backtrace` (`bt`)

When `thread backtrace` is invoked with the `--count` (`-c`) option, the
repeat command pages through the backtrace by advancing the `--start` (`-s`)
option by the count each time.

For example:

```
(lldb) bt 5
* thread #1, stop reason = breakpoint 1.1
  * frame #0: handle_request at server.cpp:50
    frame #1: parse_headers at http.cpp:12
    frame #2: read_socket at socket.cpp:30
    frame #3: accept_connection at listener.cpp:8
    frame #4: event_loop at reactor.cpp:100
(lldb)
# repeats as: thread backtrace -c 5 -s 5
* thread #1, stop reason = breakpoint 1.1
    frame #5: start_server at main.cpp:42
    frame #6: load_config at config.cpp:7
    ...
(lldb)
# repeats as: thread backtrace -c 5 -s 10
```

Each press of Enter shows the next 5 frames. If `--count` is not specified,
the full backtrace is displayed and there is no repeat command.

## `source list` (`list`)

When `source list` is repeated, it shows the next block of source lines,
continuing from where the previous listing ended. This mimics paging behavior.

If the `--reverse` (`-r`) option was given, the repeat command continues
listing in reverse (showing earlier source lines).

```
(lldb) list          # shows source around the current location
(lldb)               # shows the next block of source lines
(lldb)               # shows the next block after that

(lldb) list -r       # shows source in reverse
(lldb)               # continues listing in reverse
```

## `memory read`

When `memory read` is repeated, it continues reading from where the previous
read ended. The repeat command drops the address arguments and re-uses the same
format, size, and count options from the previous invocation.

```
(lldb) memory read 0x1000 -c 32
0x1000: 48 8b 05 a9 3b 00 00 48 ...
(lldb)               # continues reading the next 32 bytes from 0x1020
(lldb)               # continues reading from 0x1040
```

## `memory region`

When `memory region` is given an address, it displays the memory region
containing that address. Pressing Enter then shows the next memory region, and
so on, allowing you to walk through the process's entire memory map.

```
(lldb) memory region 0x1000
[0x0000-0x2000) rw-
(lldb)               # shows the next region starting at 0x2000
(lldb)               # shows the next region after that
```

## `frame variable` (`v`)

When `frame variable` is repeated, it re-runs the command with an incremented
`--depth` (`-D`) value. This progressively reveals deeper levels of nested
data structures with each press of Enter.

If no `--depth` option was specified in the original command, the next repeat
starts at one level beyond the `target.max-children-depth` default setting. If
`--depth` was specified, it increments the given value by 1 each time.

Consider a deeply nested configuration structure:

```
(lldb) v config
(Config) config = {
  server = {
    network = {
      tls = {
        certificate = {
          issuer = {...}
        }
      }
    }
  }
}
(lldb)               # repeats as: frame variable --depth 6 config
(Config) config = {
  server = {
    network = {
      tls = {
        certificate = {
          issuer = {
            name = {...}
          }
        }
      }
    }
  }
}
(lldb)               # repeats as: frame variable --depth 7 config
```

The default `target.max-children-depth` causes the first output to truncate at
`issuer`. Each press of Enter reveals one more level without having to
manually specify `--depth`.

## `thread trace dump instructions`

When repeated, this command adds the `--continue` flag, which continues
dumping traced instructions from where the previous instruction dump left off.

```
(lldb) thread trace dump instructions
... first batch of instructions ...
(lldb)               # continues dumping the next 20 instructions
```
