[lldb] Add repeat commands documentation (#194923)

   use/variable

   use/formatting

   use/repeat-commands

   use/symbolication

   use/symbols

   use/ondemand

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