The RAD Debugger / Linker v0.9.14-alpha

This release contains some small features, many bugfixes, and many performance improvements:

Debugger Features & Improvements

• The performance of the debugger's fuzzy searching mechanisms (used in autocompletion tooltips, debug information tables like Types or Procedures, and the interfaces for Go To Name and Add Function Breakpoint) have been greatly improved to be done in parallel. This will be most noticeable in larger projects.
• The debugger now does per-module syntax highlighting (for globals, types, procedures) in parallel, on background threads. This improves the performance of the debugger UI with larger projects.
• Many other various features in the debugger's UI and frontend have been tweaked to support better performance, particularly with larger projects.
• The debugger now preemptively converts adjacent PDBs to the RDI format in parallel using a limited heuristic rule. Debuggers learn of loaded DLLs serially, and they must analyze debug information for each DLL as it is loaded, before any more are loaded (to ensure that breakpoint resolution occurs correctly before resuming the target program). This means when a project loads many DLLs, it forms a long chain of serially-dependent work. For the RAD debugger, the most expensive part of this process is the conversion from PDBs to RDIs (after RDIs are produced, it is nearly instantaneous to load them). This heuristic rule is intended to, in a conservative manner, locate adjacent DLLs which are likely to be loaded given the filesystem's directory structure, and given the set of modules already loaded, and preemptively convert the PDBs for those DLLs, so that when a target application does load those DLLs, the RDIs are already prepared. This should help initial startup times for larger projects, after a clean rebuild, which use many DLLs (once the RDI files are produced, they do not need to be recreated until the DLL is rebuilt, so they can be cached in the common case in such projects).
• The debugger now accounts for DPI when choosing font sizes on first-time startup. (#341)
• The debugger now defaultly does not attach to subprocesses; this is more optimal for certain project styles. For the cases when the old behavior is desired, automatically attaching to subprocesses can now be enabled on a per-target basis.

Debugger Fixes

• The debugger now supports cancellation of fuzzy searching, which was previously causing delays when killing processes with a large number of large DLLs loaded (because a slow fuzzy search was still occurring in the background).
• The debugger now correctly handles unary + operators.
• The debugger now correctly parses exponentiated numeric literals. (#323)
• In cases where debugger collections like modules, registers, and so on, were found as symbols in an attached program (e.g. local or global variables), the debugger would incorrectly display the Locals, Registers, or Modules views. This has been fixed. (#337)
• Some cases of incorrect syntax highlighting in disassembly views were fixed. (#337)
• A bug where the memory view would show incorrect byte values at certain scroll positions has been fixed. (#353)
• A bug where 64-bit bitfield types were not displaying correctly has been fixed. (#355)

Linker Features & Improvements

• Added detection for libs without extension specified with /defaultlib and directive.
• Added /nod alias for /nodefaultlib
• Switched symbol table data structure to hash trie map.
• Added logic for handling communal variables.
• Added /rad_pdb_hash_type_names that replaces type names with hashes, helps cut down TPI stream size.
• When /debug:fastlink is specified linker shows an early warning.
• Reduced number of memory copies needed to serialize image.

Linker Fixes

• Fixed section number promotion to 32 bits bug when creating COMDAT associations in big objs.
• Fixed build errors and warnings on Linux.

The RAD Debugger v0.9.13-alpha

This release is the first which contains the RAD Linker, which is an in-progress drop-in replacement for MSVC's linker. You can read more about that here. Importantly, this linker is capable of natively generating the RAD Debug Info format, which the debugger otherwise produces by converting information found inside of PDB files.

This release also contains a number of debugger bugfixes, performance improvements, and a few small feature additions:

Features & Improvements

• The debugger now supports overriding stdout, stderr, and stdin with file paths on a per-target basis.
• The debugger now disambiguates filenames shown in tab titles (#330).
• Improved disassembly snapping rules, to more closely align with what the user is currently looking at (it will not snap to disassembly in cases where you are mainly focused on source code).
• Improved performance of the Scheduler view, and of source code views with heavily-inlined code. Makes the debugger perform significantly more reasonably with larger projects.
• Numeric values of enum evaluations now respect radix view rules (oct, bin, dec, hex). (#337)

Fixes

• The debugger now correctly deterministically produces RDIs given the same PDB input.
• The debugger now correctly supports using arbitrary symbol identifier syntax (using ` characters to surround an arbitrary string) to look up type names.
• Fixed blank views being opened via the Switch command, if not done from an existing tab.
• Fixed double clicking whitespace at the beginning or end of a line causing a malformed search string.
• Fixed IPC commands incorrectly parsing file path arguments. Commands like raddbg --ipc run_to_line C:/foo/bar/baz.c:123 should now work correctly.
• Fixed incorrect disassembly snapping rules.
• Fixed freezing threads, while attached processes are running, causing halts (without subsequently resuming).
• Fixed incorrect ordering of inline frames in the Call Stack view.
• Fixed incorrect results in Modules, Registers, and Locals views, when their respective collection names collide with names in an attached process. (#337)
• Fixed writing enum values in the Watch view failing. (#337)

The RAD Debugger v0.9.12-alpha

This release is another substantial one, with several improvements and upgrades to several core debugger systems.

It contains many changes that may impact existing configuration files. If you run into issues or just want a fresh start, it may help to delete your user / project files, although it ideally will still work with old ones.

Like with any large release, a lot of code has changed, and so you may run into new or unexpected issues. If you do, we'd greatly appreciate it if you'd report the issue with as many details as possible. As always, we appreciate your patience, enthusiasm, and willing to give the debugger a try to help it through its alpha phase. Following this release, we plan on doing a larger number of smaller & more focused releases, to focus on usability, reliability, & stability.

Features & Improvements

• The view rule visualizer systems and the other various visualizer systems (those for source code, the memory view, the disassembly view, and more) have been unified; as such, all visualizers can be used with view rules to provide an interface identical to anywhere else they're used in the debugger. The text view rule is now identical to a source code view. The disasm view rule is now identical to a disassembly view (but just locked to a specific evaluation). Evaluations with these view rules specified in a Watch tab can be popped out to standalone tabs.
• File paths can now be evaluated (via file:"C:/foo/bar/baz.txt").
• A new memory view rule has been introduced, which instantiates the hex-viewer memory visualizer for a particular evaluation. This evaluation can include files, meaning this visualizer can be used as a hex-viewer for files.
• The debugger now supports native drag + drop, so you can drag + drop files onto the debugger to quickly open them. For executable files, the debugger will also present an extra query to either add the executable as a target, and optionally run or step into it. In all other paths, the debugger will open the most appropriate view rule it has; currently, this just includes the text view rule for textual files, and memory for anything else, but this will expand in the future.
• Custom definitions in the watch window (e.g. x = 123) are now supported in all evaluations, and they're no longer locked to being used within a single Watch tab.
• Auto view rules have been introduced, which automatically associate a given type expression with a view rule. Unless otherwise specified in a given evaluation's view rule, evaluations of that type will use the associated view rule automatically. (#118, #312)
• A new slice view rule has been introduced, which attempts to interpret a struct or class as containing a pointer, and an integer encoding the number of elements to which the pointer points, and then visualizes the pointer as pointing to that many elements (as if array was used).
• A new cast view rule has been introduced, which allows casting of expressions from an evaluation's view rule.
• A new wrap view rule has been introduced, which allows changing the evaluated expression by containing it within another expression. For example, x with wrap:{$expr + 5} applied, will evaluate as x + 5.
• The only view rule now defines the order of struct or class members as they're visualized, in addition to its old functionality of choosing which members to show.
• The debugger now supports evaluations across all loaded modules, with all loaded debug info; you no longer have to select a thread & call stack frame within the module with the debug information with which you want to evaluate. (#185)
• The debugger now supports evaluation of breakpoint state. This is easiest to do by giving your breakpoints a label (this can be done either by right-clicking them, or by editing them in the Breakpoints view). These can be used to build dependent breakpoints, as these evaluations can be expressed in breakpoint conditions as well. For instance, I can make the condition of one breakpoint: other_breakpoint.hit_count > 0. This condition, in particular, will not incur the usual target runtime performance costs of conditional breakpoints.
• Similar to breakpoints, the debugger now supports evaluation of thread state. This is not yet supported in conditional breakpoints, but it will be soon. These evaluations can be placed in a Watch window though.
• All watch-style tabs can be evaluated as watch expressions. Locals can be reproduced in the Watch tab by evaluating the locals expression. Registers can be reproduced by evaluating the registers expression. Globals, via globals, Types, via types, Procedures, via procedures, and so on. This allows all of these collections to be fuzzy-searched together.
• The debugger now supports evaluations of small (64 bytes or less, currently) string literals, and equality/inequality comparisons between them. These can be used in conditional breakpoint expressions as well. (#213)
• typeof is now supported in evaluations.
• The debugger has switched to using the Zydis disassembler library, which contains better correctness & support for newer x86 instructions and extensions. (#259, #169)
• The autocompletion lister has been greatly improved, supporting the autocompletion of globals, procedures, types, file paths (when relevant), and more.
• The debugger UI now supports modification of multiple keybindings per command.
• A new Toggle Watch Expression At Mouse command has been added.
• The Output view now automatically scrolls to the bottom. This is not configurable yet.
• A new bring_to_front command has been introduced; it can be used via IPC. (#326)
• The debugger's text rendering has been improved to improve smoothness and anti-aliasing when appropriate. This can be configured in Settings.
• The debugger now correctly supports textual hotkeys. If text is not being inserted in the UI anywhere, then textual keys (like n or s or r) can be used for commands.

Fixes

• The debugger now correctly evaluates AVX-512 register evaluation. (#290)
• The debugger has a small fix covering a number of unwinding edge cases, which may improve call stack quality. (#313)
• Ternary operators in evaluations have been fixed.
• The debugger evaluation visualization systems have been largely rewritten to improve their robustness, correctness, and feature coverage. This eliminates/reduces cases where, previously, view rules would not be applied correctly.
• A bug was fixed where font paths specified in configuration files would be doubly-escaped, leading to exponential (!) growth of configuration files. Sorry about that one!
• The debugger now un-minimizes and regains focus when encountering an exception or interruption.
• The Output view flickering has been fixed. (#278)
• The Breakpoints view, as well as all other similar views, now support multi-selection, reordering, deletion via the Delete key, and other keyboard shortcuts (as they have been largely deduplicated with Watch or Watch-like views). These should now all behave in a less idiosyncratic way.
• Many other small fixes and improvements.

The RAD Debugger v0.9.11-alpha

This release includes several major improvements and upgrades to many significant systems in the debugger.

Features & Improvements

• The RDI format has been majorly simplified and expanded to support inline information. This information is now parsed and produced by the PDB -> RDI converter. (#214)
• The debugger UI has been extended to display inline information, including inline frames, and mapping addresses to inline line information. (#214)
• Major improvements to OutputDebugString performance.
• Major improvements to conditional breakpoint performance. (#265)
• A new Settings view has been added to replace the old Theme view. This view still allows the editing of the theme, but also editing other settings, including the enabling/disabling of animation or visualization features, and the number of spaces a tab should render as.
• The source code view now displays tab characters correctly, rather than just as a single space. The number of columns that tabs occupy can be configured in the new Settings view.
• Profile files have been renamed to project files, to avoid confusion.
• User files now keep track of a history of recently opened projects. A new command, Open Recent Project, has been added to easily select amongst these.
• Source code tabs are now serialized as being tagged with their associated project file. Only source code tabs associated with the active project file will be visible. This improves the flow of switching between projects often.
• Extended the source and Disassembly views to have two margins, one for the selected thread, and one for all other threads, watch pins, and breakpoints. This eliminates some visual noise, and makes it easier to distinguish a selected thread from other threads.
• Introduced UI to perform both mouse-driven completion and cancellation of a query.
• Local variables in the Locals view are now sorted in the order they are stored in debug info. In the future, more sorting options will be available. (#257)
• The menu bar is now less idiosyncratic, in that it supports traditional Windows-style click + drag (across several in-menu-bar buttons) behavior.
• The theme colors have been adjusted to be more explicit, have fewer overloaded meanings, and to be more useful for a variety of themes.
• The visuals of several interfaces in the debugger have been cleaned up and simplified.
• Icons are no longer rendered with font hinting and only horizontal anti-aliasing enabled. This should make them appear much smoother.
• The query string for Find Text Forward (Ctrl + F by default) is now auto-filled by whatever string was last selected in a source or disassembly view.
• Improved the behavior of color pickers to correctly retain the original color if Escape is pressed during a drag.

Fixes

• Fixed confusing rules regarding rolling back a thread, after it hits an int3 which is baked into the instruction stream. (#223)
• Fixed a UI bug which disallowed the creation of new user and project files.
• Fixed some issues in the renderer prohibiting the debugger from being used on Windows 7 systems.
• Fixed some issues in the operating system layer prohibiting the debugger from being built on Windows 7 systems.
• Fixed annoying scroll-on-drag behavior in the source, Output, Memory, and Disassembly views, which would scroll the view when the mouse was still within the visible region.
• Fixed incorrectly-reported exceptions when stepping through code simultaneously executed by many threads.
• Fixed several major stepping bugs, manifesting sometimes as a program exiting immediately after stepping, or as a program continuing execution after stepping, as if F5 was pressed.
• Fixed function breakpoints working incorrectly after they had been hit more than once.
• Fixed Ctrl + Scrolling not correctly resizing source code, if the empty region after a source code file's contents was hovered.
• Fixed non-deterministic RDI generation, due to incorrect asynchronous task dispatch in the PDB -> RDI converter.

The RAD Debugger v0.9.10-alpha

This is a fairly major release consisting of many large passes over many parts of the codebase. This simultaneously means you might notice some cool new things, and you might notice some accidental regressions or bugs! If you notice a new issue, please don't hesitate to post about it, so it can be quickly addressed.

Here is a list of the most major upgrades or changes:

Features & Improvements

• The Disassembly view now supports disassembly intermixed with source code, if debug info and source code is present.
• Major upgrades to panel organization UI. Dragging and dropping tabs can now also be used to split panels and move tabs in a single operation (similar to other standard panel organization UIs), making the most common panel rearrangement operations a breeze.
• Watch and Watch-like views now support multi-row selection and multi-cursor editing.
• Watch views now support reordering.
• Major upgrades to the autocompletion lister UI. Can now be used to autocomplete multiple times in a single expression, without autocompletion actions causing editing to stop. The autocompletion lister is also now more aware of the context in which you type; if specifying view rules, it will show a list of possible view rules. If specifying parameter names to a view rule, it will show a list of possible parameter names. If specifying a parameter, it will show possible useful autocompletions for whatever that parameter requires (e.g. an arch parameter will show autocompletions for architectures; a fmt parameter for a bitmap view rule will show autocompletions for 2D texture formats, and so on).
• When editing rows in a Watch view, the expression will now update immediately as you type.
• The frontend now provides its own custom window border, leaving more of the window available for debugging controls.
• The bitmap view rule can now be popped out into a standalone tab, which offers a more full bitmap viewing UI. This is currently incomplete, but already offers better inspection controls for bitmaps, with a zoomable canvas view. This same pattern will be used in the future for other more sophisticated view rules.
• The debugger now lexes (syntax highlights, supports eval-on-hover, and so on) Jai and Zig files.
• The debugger now outputs logs of every run to %appdata%/raddbg/logs, which can help provide extra information in case of issues.
• The source view now displays the margin and line numbers as floating and always visible, when horizontally scrolled.

Fixes

• The debugger now more correctly supports updated debug info for hot-reloaded executables and DLLs.
• The debugger now displays HRESULT numerical codes. (#202)
• The debugger now properly sanitizes (escapes, trims whitespace) strings for serialization and deserialization. This fixes issues with backslashes and leading or trailing spaces in various user-entered strings, like those in a target's information. (#197, #207)
• The debugger now better responds to scrolling on trackpads. (#178)
• Many issues with IPC commands have been fixed. Many broken cases have been fixed, and they now execute immediately and do not require interaction with the UI. (#157)
• Unwinding and snapping to threads in JIT'd code has been fixed.
• A number of crash fixes, and otherwise stability improvements.

The RAD Debugger v0.9.9-alpha

This release consists of a lot of behind-the-scenes work, primarily focused on improving the PDB -> RADDBGI conversion speed for larger projects, and cleaning up and simplifying many lower level debugger systems, to have a more solid foundation for further features and improvements moving forward.

Before this release, the PDB -> RADDBGI conversion process was completely single-threaded, and was not usable for large PDBs, and especially not in projects with several large PDBs. There are still plenty of performance improvements on the table, and we expect this to continue to improve, but this release already includes some major improvements. With our 8GB test PDB (the largest that we currently have), on a 64-core development workstation, conversion time decreased from ~11 minutes to ~30 seconds with the changes in this release. This should massively improve the debugger's usability in many cases where it was previously not usable.

As a result of the above progress, as well as all of the aforementioned work on the lower level debugger systems, a lot of code was either majorly changed or rewritten. If you experience new issues with this release that you didn't experience with older versions, it'd help out a lot if you let us know by submitting an issue.

EDIT: The new PDB -> RADDBGI converter had introduced some regressions, mostly related to C++ feature support. I've since fixed these. Since these are small fixes, but quite important for regular debugger usage for many people, I wanted to package up a new build with these fixes included. That being said, I didn't think these fixes alone justified an entirely new release with a new version number. So I've uploaded an updated build under raddbg.zip. The original build has been renamed to raddbg_0.9.9a.zip.

A more comprehensive list of the major improvements and fixes follows:

Features & Improvements

• Major pass over the PDB -> RADDBGI converter to improve memory usage and performance, particularly with very large PDBs. (#145)
• The Disassembly view now works for dynamically allocated and generated code, and correctly hot-reloads as the underlying memory changes. (#106)
• The debugger now supports evaluating and visualizing bitfields. (#54)
• The source and disassembly views now support double-click to select by token, and triple-click to select by line. (#81, #45).
• The Disassembly view now correctly supports keyboard navigation, copy/paste, and the toggle-watch-expression-at-cursor command.
• Syntax highlighting and basic hover-evaluation support for the Odin language.
• Middle click now closes tabs. (#88)
• More visible & more informative exception visualization.
• Support for address and code byte toggling in Disassembly views.

Fixes

• Fixed a crash when changes in a Watch view were committed when the selected row was not visible. (#133, #174, #176)
• Fixed several process control and caching issues in the debugger's backend, eliminating several evaluation and usability issues.
• Fixed a crash when viewing more complex Unicode strings in Watch views. (#165)
• Fixed crashes in the evaluation expression parser, relating to incomplete/malformed expressions. (#155)
• Fixed some issues with PDB line info parsing, which caused line info to "disappear" midway through a function. (#138)
• Fixed the debugger's incorrect interpretation of UTF-16 and UTF-32 strings as UTF-8, causing incorrect visualization. (#180)
• Fixed the debugger backend hanging when encountering uncaught exceptions, when those exceptions were specified to be filtered on first-chance encounters. (#151)
• Fixed parsing of C++ digit separators. (#173)
• Fixed the debugger being unable to correctly locate debug info because of differences in case-sensitivity in various usages of a path.
• Fixed the frontend's input event consumption to be more correct and robust. (#91)

The RAD Debugger v0.9.8-alpha

This release includes the following improvements and fixes:

• New fuzzy-filtered, debug-info-driven procedure name list interface, used for the Go To Name and Function Breakpoint commands.
• New Types, Procedures, Globals, and Thread Locals views. These are automatically-filled Watch-style views that display all known types, procedures, globals, and thread-locals (respectively) in the selected module's (determined via the selected thread) debug information. These support fuzzy filtering, to filter down their generally large contents. Fuzzy filtering can be applied by typing in any of these views, or by explicitly running the "Filter" command.
• Extended type evaluation support in Watch and Watch-style views.
• Cache line and padding visualization in Watch and Watch-style views.
• Fuzzy filtering support for Watch, Locals, Registers, Breakpoints, Watch Pins, Targets, Scheduler, Modules, and Exception Filters views. The fuzzy filtering may be applied identically to the aforementioned Types/Procedures/etc. views.
• Partial callstack information visualization per-thread in the Scheduler view. This callstack information can also be filtered against, providing more convenient searching/sorting through threads, even when they're unnamed.
• Support for "macros" in the Watch view. These allow the assignment of expressions to a label. Given the syntax x = expr, in all other Watch rows, the when x occurs in the expression, its evaluation will be equivalent to that of expr. x must always be some identifier (that does not collide with any local variables, global variables, or types), and expr can be any valid expression.
• Direct visualization of failed memory reads in Watch and Watch-like views.
• Better support for line information and stepping in programs generated with the /JMC MSVC option. (#36)
• Fixed a number of cases in which the debugger UI was updating repeatedly when unnecessary. (#125)
• Fixed the debugger's interpretation of thread naming events that were sent to name threads other than the thread which generated the event. (#127)
• Fixed the debugger's usage of thread naming events when the debugger had not yet been fully notified of the associated thread's creation. This is mostly associated with the creation via CreateThread and subsequent naming of threads with the CREATE_SUSPENDED flag. (#127)
• Improved the debugger's strategy for locating target entry points in various circumstances, including with executables that were not linked with the C runtime, and those that specify a custom entry point. (#61, #120)
• Many other small tweaks, fixes, and improvements.

The RAD Debugger v0.9.7-alpha

This release includes the following improvements and fixes:

• Further extended support for implicit namespace resolution in the evaluation system. (#55)
• Support for C++ scope resolution operators in hover evaluation paths. (#55)
• Extended the run-to-line command to work irrespective of whether or not a target is running. (#113)
• Fixed mistreatment of AltGr inputs, causing spurious and incorrect menu bar focusing. (#59)
• Implemented watch window change visualization, displaying when values in the watch window change after debuggee processes run. (#39)
• Improved defaults for multi-target debugging; should prevent many cases when multiple targets are accidentally run, when only one was intended.
• Many bugfixes relating to newer PDB symbols. This should fix some incorrect values or missing struct/class members. (#114)
• The debugger now displays the full contents of a truncated string as a tooltip, if the mouse hovers the truncated string for a short time.
• Fixed double-quoted strings in user-specified strings, including those attached to targets, breakpoints, or watch pins.
• Fixed incorrect splitting of double-quoted target arguments. (#122)
• Fixed synchronization bugs with Output log. This fixes some flickering and crashing with OutputDebugString-heavy programs. (#123)
• Eliminated more overdraw and unnecessary work in the debugger's UI building and rendering code. This should further improve the frontend's performance on e.g. integrated GPUs.

The RAD Debugger v0.9.6-alpha

This release includes the following improvements and fixes:

• Fixed member access operations on references. (#83)
• Fixed member access, and other, operations on modified (e.g. const) pointer and reference types. (#83)
• Fixed crash in memory view, when going to an out-of-bounds address. (#79)
• Type expression evaluation, where the watch window evaluates types as well as values. The visualized type information is mostly empty at this point, but this allows viewing a type's members without needing to produce an artificial pointer to that type's instance (e.g. by watching (MyStruct *)0). This will be extended in the future.
• Fixed broken OutputDebugString output. (#96)
• A new, rewritten "command query" system. This improves & simplifies the debugger's interfaces (and implementations) for the command palette/lister, file picking dialogues, and attaching dialogues.
• Warning if a 32-bit application is attempted to be launched, as that is currently an unsupported case.
• An application icon, so that the debugger may be more easily identified on the task bar.
• Many improvements to rendering performance, to reduce overdraw and simplify shader work. This greatly improves the UI's performance on older or lower power graphics cards (e.g. integrated GPUs).
• Fixed memory view updating when memory is changed via edits in the watch window. (#92)
• Fixed callstacks and disassembly when stepping through dynamically generated (e.g. JIT-compiled) code. (#106) The debugger is still not fully equipped to handle dynamic JIT-compiled code in that the disassembly view doesn't hot-reload decoded disassembly instructions when the underlying code memory is changed, but this will be addressed in a subsequent release.
• Improved folder selection interface, to omit files and actually provide a path to select a directory which has been navigated to. (#85)
• Support for hitting Space to expand watch window trees, as well as Enter.
• Fixed bug, where debugger would launch & attach to multiple instances of the same program when running step-into or step-over commands, if waiting for an initial process to start. (#100)
• Improved rules for selecting file replacements/overrides. The debugger will now try to override matching directories to whatever file was overridden, if possible. This should improve the experience when debugging an executable when the source for which has moved. (#112)
• Fixed some incorrect variable location info interpretation/usage in the convert and debugger. This should fix some issues with incorrect values being reported by the Watch view.
• Preference for name matching against later-added global variable symbol debug info, rather than earlier, in cases where PDBs store both (and keep stale global variables around). This should also fix some issues with incorrect values being reported by the Watch view.
• Added a "Switch To Partner File" command, for quickly switching between e.g. .h and .c files.

The RAD Debugger v0.9.5-alpha

This release includes the following improvements and fixes:

• Fixed the debugger's behavior of exclusively locking source files.
• Fixed failed instances of debug info conversion (e.g. due to currently-unsupported edge cases) spamming fatal exception message boxes. (#64)
• The debugger will now automatically select the previous search query when performing a textual search, subsequent to an earlier search. (#62)
• The debugger will now warn if a source code file's timestamp is newer than any of the module files it is currently being used to debug. (#13)
• Implemented register value committing in watch / evaluation views. (#44)
• The debugger now includes Address Sanitizer support; it will not stop due to exceptions used to implement Address Sanitizer's shadow virtual address space mapping technique.
• The debugger will now search for executable-embedded debug info paths relative to the executable, when loading debug info. (#32)
• The debugger will now allow name mapping that implicitly makes use of the selected thread's current function namespace, when evaluating expressions. For example, evaluating Foo::X when inside of Foo::Function can now be done by evaluating X. (#55)
• The debugger will now display the decimal version of enum values when mapping the value to an identifier fails.
• The debugger now has an exception filter setting for DirectX debug layer exceptions.
• The debugger's file system lister will now display modification timestamps in the local time zone.