This is a small follow-up release to v0.9.19 with fixes, improvements, expanded support, and some new features.

Debugger Changes

• Added the ability for pattern-based type view expressions to use parts of the evaluation's type string (which matched the pattern's wildcards). This is done by adding {<comma-delimited-identifiers>} after a ? used in a type pattern. For example, with the pattern DynamicArray<?{element_type}>, the expression can be array(cast(element_type *)base_pointer, count).
• Added built-in type views for a number of basic Unreal Engine types. These can be enabled or disabled with the Use Default Unreal Engine Type Visualizers setting.
• Added support in RDI for constants defined in debug information, like enum members or global constant values. Also added support for evaluating and autocompleting these constants.
• Added the ability to programmatically construct memory range annotations from target applications with the raddbg_annotate_vaddr_range API in the raddbg_markup.h header library.
• Added automatic memory annotations for globals and procedures found in debug information.
• Improved memory range annotation UI in the memory view.
• Added support for "rich hover" visualization in the memory view and watch tables. When address ranges are hovered in a watch table or memory view, the same addresses will be highlighted in the other; this makes it much easier to correlate between the two views.
• Greatly improved PDB -> RDI conversion speed (fixed regressions caused by non-parallelized inline site conversion).
• Improved the behavior of the find_code_location command to account for multiple windows. Instead of snapping all windows to the destination source code, it will be smarter about which windows are being used for source code and disassembly.
• Fixed a regression with pattern-based type views, which was preventing more complex templated evaluations from correctly having views applied to them. (#517)
• Fixed a bug where the Go To Address command was not snapping the memory view's scroll position to the destination address correctly.
• Fixed various other small bugs in the memory view.
• Fixed some cases where the debugger was not normalizing paths correctly, which caused paths with forward slashes and backwards slashes to be treated differently. (#521)
• Fixed the debugger not storing projects created via Save Project as recent projects, thus preventing them from being automatically reloaded on subsequent runs.

Linker Changes

The linker is unchanged since v0.9.19.

Binary Utility Changes

In previous releases, we packaged our command-line binary analysis utilities like rdi_dump, rdi_from_pdb, and rdi_breakpad_from_pdb along with the debugger and linker binaries. These have been combined into a single program called radbin. radbin can be used to convert PDBs to RDI, to convert PDBs to the textual Breakpad format, and to dump textualizations of all information within an RDI file, so it can be easily inspected in a text editor.

Here are some examples of how one can use radbin (assume that program.exe's debug info is in program.pdb):

• radbin --rdi program.exe: Finds the debug info for program.exe, and converts it to the RDI format, outputting it to program.rdi.
• radbin program.exe --out:program.rdi: Equivalent to above.
• radbin program.pdb --out:program.rdi: Equivalent to above.
• radbin --rdi program.pdb: Equivalent to above.
• radbin --dump program.rdi: Dumps a textualization of all debug information inside of program.rdi to stdout.
• radbin --breakpad program.pdb: Converts debug info in program.pdb to the Breakpad text format, outputting it to program.psym

As usual, all of the binaries we package in each release are standalone. None of them require any of the others to be used.

The debugger executable also contains all of radbin's functionality within itself. It can be used by passing the --bin argument to the debugger. For instance, raddbg --bin --rdi program.exe is equivalent to radbin --rdi program.exe, and raddbg --bin --dump program.rdi is equivalent to radbin --dump program.rdi. That said, because the debugger is built as a graphical program, it will not output its stdout and stderr output to a terminal from which you run it (it can still be piped to an output file, however, like raddbg --bin --dump program.rdi > program.dump).

As we continue making progress on the Linux port, or otherwise expanding our support for the many debugger-and-linker-related file formats, radbin will expand in functionality.