* support for custom disassemblers allowing for custom code analysis (not part

```

| b0 thread frame i r |

"Create new debugger object - `gdb`."

gdb := GDBDebugger new.

"Load an executable to debug, the parameter is a String

 with path to the executable."

gdb executable: GDBDebuggeesResource current binaryFactorial1.

"Set breakpoint on function `factorial(int)`, see`factorial.c`(*).

 Here we use `GDBDebugger >> #send:` to send a standard CLI command

 to `gdb`. The method blocks and returns once the command is executed.

 See class `GDBDebugger`, protocol 'commands' for more ways to send a

 command to GDB.

 (*) https://jan.vrany.io/hg/jv-libgdbs/file/tip/tests/c/factorial1.c

"

gdb send: 'b factorial'.

"You may ask `gdb` for list of breakpoints, ..."

gdb breakpoints.

"...retrieve a breakpoint as an object..."

b0 := gdb breakpoints first.

"...and then use breakpoint object to get details

 for example on what file and line the breakpoint was

 put:"

'location is %1 : %2' bindWith: b0 file with: b0 line.

"Breakpoint objects can also be used to manipulate it,

 for example to set a condition when the breakpoint should

 hit. See class `GDBBreakpoint`. "

b0 condition: 'i == 1'.

"Now let's run debuggee util it hits the breakpoint using

 GDB's `r` (or `run`) command. Here we (have to) use a different

 API than plain `#send: - `#send:` executes the command and return

 as soon as the command is executed. This is not what we want now,

 here we want to run the debuggee and wait until breakpoint hits

 (or until some error occur). In theory, this could be hours after

 the `r` command is executed.

 For cases like this, libgdb's provides another API:

 `GDBDebugger >> send:andWaitFor:` to wait for 'stopped' event:"

gdb send: 'r' andWaitFor: GDBStoppedEvent.

"Now let's see where we have stopped. Since GDB allows

 to debug multiple processes (called inferiors in GDB parlance)

 and each process may have multiple threads, we have to first get

 a the thread and then ask the thread for first (newest) frame of

 threads callstack. In this case, there' only one process with

 only one thread, so getting the thread is easy.

 Note, that there's always a callstack with at least one frame."

thread := gdb selectedInferior threads first.

frame := thread stack first.

"Again, thread and frame are objects and can be used to access

 program state"

frame func.    " -> 'factorial'"

i := frame variables first.

i name.        " -> 'i' "

i value.       " -> '1' "

r := frame registers first.

r name.        " -> 'rax' (depending on target architecture, of course) "

r value.

"Finally, remove all breakpoints and let the program continue and finish..."

gdb send: 'del'.

gdb send: 'c' andWaitFor: GDBThreadGroupExitedEvent.

```

2.  Get suitable GDB. Stock GDB 13 and later should be fine.

3.  Get [Smalltalk/X jv-branch][3]. Pre-build "toy" binaries for Linux

    can be found at [https://jan.vrany.io/download/smalltalkx/devel][5]:

        wget https://dl.vrany.io/public/smalltalkx/devel//YYYY-MM-DD_NNN/smalltalkx-jv-branch-8.0.99_buildNNN_x86_64-pc-linux-gnu.tar.bz2

        hg clone https://jan.vrany.io/hg/jv-libgdbs jv/libgdbs

Jan Vrany `<jan [at] vrany [.] io>`

[3]: https://jan.vrany.io/stx

[5]: https://dl.vrany.io/public/smalltalkx/devel

[6]: https://jan.vrany.io/stx/report/9

[7]: https://jan.vrany.io/stx/newticket

[11]: https://jan.vrany.io/public/gdb

[12]: https://jan.vrany.io/stx/wiki/Documentation/BuildingStXWithRakefiles