lldb-mi
rr
lldb-mi | rr | |
---|---|---|
12 | 113 | |
167 | 9,224 | |
3.0% | 0.6% | |
2.4 | 9.6 | |
4 months ago | 7 days ago | |
C++ | C++ | |
GNU General Public License v3.0 or later | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
lldb-mi
-
Waiting for... a Debugger
When using a debugger such as gdb or lldb, typically you:
-
My Personal Serverless Rust Developer Experience. It’s Better Than You Think
I'm on the record of loving the VSCode experience with Rust. And I do think that it's amazing that a "non-IDE" can feel so much like an IDE. However, I've recently pivoted off of that stance. I know it's still in EAP, but Rust Rover gives me all of the things that I get from VSCode plus an easier integration with LLDB.
-
Taming the dragon: using llnode to debug your Node.js application
Fortunately, we can use this same technique with our Node.js applications! This is possible through llnode: a LLDB plugin which enables us to inspect Node.js core dumps. With llnode, we can inspect objects in the memory and look at the complete backtrace of the program, including native (C++) frames and JavaScript frames. It can be used on a running Node.js application or through a core dump.
-
How to debug programs in console? (C program for example)
An alternative to gdb is lldb. But I like gdb.
-
How to Debug WASI Pipelines with ITK-Wasm
The CMake-based, itk-wasm build system tooling enables the same C++ build system configuration and code to be reused when building a native system binary or a WebAssembly binary. As a result, native binary debugging tools, such as GDB, LLDB, or the Visual Studio debugger can be utilized.
-
What is the debug drawer?
The debugger component of the LLVM project. It’s what you’re typing into when you type po someExpression. https://lldb.llvm.org/ Web searches could help explain a lot of this for you 😊
-
Best debugger for windows? GDB is not stable and can't seem to find an alternative.
If you really don't want to touch Visual Studio/MSVC then you can try to compile with clang and use lldb: https://lldb.llvm.org/
-
dap: configuration to automatically launch codelldb server
LLDB - https://lldb.llvm.org/ - Debugger from the LLVM project
-
Debugging with GDB
Well, there's LLDB (https://lldb.llvm.org/) - I've heard it's got some nifty architectural features (e.g. having access to the Clang framework for handling C/C++ expressions).
I've done some minimal poking about in the code; I found its object-orientation a bit hard to grok (just for me personally) but it seemed to be quite uniformly applied so it might well be easier to work with.
-
Write your GDB scripts in Haskell
The article does mention lldb as a future target.
rr
-
Don't Look Down on Print Debugging
https://learn.microsoft.com/en-us/windows-hardware/drivers/d...
Or on Linux use rr (https://rr-project.org/) or Undo (https://undo.io - disclaimer: I work on this).
These have the advantage that you only need to repro the bug once (just record it in a loop until the bug happens) then debug at your leisure. So even rare bugs are susceptible.
rr and Undo also both have modes for provoking concurrency bugs (Chaos Mode from rr - https://robert.ocallahan.org/2016/02/introducing-rr-chaos-mo..., Thread Fuzzing from Undo - https://undo.io/resources/thread-fuzzing-wild/)
- Seer: A GUI front end to GDB for Linux
-
Net 9.0 LINQ Performance Improvements
> IntelliTrace is one that comes to mind - there’s nothing remotely close to it’s snapshot debugging that I’ve seen anywhere else, and I’ve really looked.
https://rr-project.org/
- Greppability is an underrated code metric
-
Tbsp – treesitter-based source processing language
Hi, in case you're not already aware of the name clash, there's already a `rr` in the programming world. It's "record and replay": https://rr-project.org/.
Very different, but a very fine tool tool.
-
Deterministic Replay of QEMU Emulation
I don't know, however a key element is:
> Record/replay system is based on saving and replaying non-deterministic events
> The following non-deterministic data from peripheral devices is saved into the log: mouse and keyboard input, network packets, audio controller input, serial port input, and hardware clocks (they are non-deterministic too, because their values are taken from the host machine). Inputs from simulated hardware, memory of VM, software interrupts, and execution of instructions are not saved into the log, because they are deterministic and can be replayed by simulating the behavior of virtual machine starting from initial state.
So, it's probably not much, you can probably comfortably save minutes of qemu sessions.
Also note the existence of the rr debugger [1], which allows you to reverse debug applications with a ~10% performance hit while recording. To achieve this, it records results of syscalls (only). It will serialize thread events, so have the effect of running applications like on a single core CPU.
[1] https://rr-project.org/
-
How does it feel to test a compiler?
rr.
rr rr rr rr.
rr!
When testing "algorithmic" modules like compilers, it's basically a productivity cheat code to run the tests under https://rr-project.org/. Doing so allows you to deterministically replay execution, seeking forwards and backwards in the timeline of your program's execution, and quickly locate what went wrong in any computation.
For example, if we have
struct CircleDescription {
-
rr – record and replay debugger for C/C++
It says on https://rr-project.org/ that it supports Go programm, what's the status?
-
GTFL – A Graphical Terminal for Common Lisp
This was because no matter how hard I tried, I kept running into variables that I was watching that appeared to be the same reference, have different values (so I know I was referring to something wrong, but could not for the life of me figure it out, and though if I only had a way to step/trace and do this visually like an AST that highlights changed values and you could see back to its root where it's actually being modified visually)
I found out there's a thing called "deterministic debugging" (and the biggest known example afaict is rr: https://rr-project.org/
Apparently MS has a time-travel debugger... I pictured the AST being populated and repopulated via the steps, and the ability to diff changes over time.
Here's a wiki on various systems, though most of these seem to be typical text based "trace" options.
https://en.wikipedia.org/wiki/Time_travel_debugging
- rr: Lightweight Recording and Deterministic Debugging
What are some alternatives?
gef - GEF (GDB Enhanced Features) - a modern experience for GDB with advanced debugging capabilities for exploit devs & reverse engineers on Linux
CodeLLDB - A native debugger extension for VSCode based on LLDB
gdb-dashboard - Modular visual interface for GDB in Python
Module Linker - browse modules by clicking directly on "import" statements on GitHub
vscode-lldb - A native debugger extension for VSCode based on LLDB [Moved to: https://github.com/vadimcn/codelldb]
rrweb - record and replay the web
voltron - A hacky debugger UI for hackers
clog-cli - Generate beautiful changelogs from your Git commit history
lldb_batchmode.py
nbdev - Create delightful software with Jupyter Notebooks