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.

This is a small follow-up release to v0.9.18 to fix the biggest usability issues (largely due to the new asynchronous call stack computation system) and offer a few new improvements. If you're coming from v0.9.15 or earlier, we recommend reading the release notes from v0.9.16 and later, as they contain many important updates.

Debugger Changes

• Added a visualization to show the last hit breakpoint. (#249)
• Added a setting to prefer the operating system's native file picker dialog, over the built-in UI.
• Improved change and memory-read-error visualization in watch tables, to clearly display when certain address ranges either recently changed, or could not be read from a debuggee address space. (#199)
• Improved the debugger's behavior when waiting for new asynchronously computed call stacks or process memory. The debugger UI will now wake up when new results are ready.
• Fixed a bug where the debugger would not correctly generate call stacks if a zero instruction pointer were at the top of the call stack. (#398)
• Fixed a bug where the debugger would hold handles open to DLLs while the UI was not being interacted with, causing debuggees to freeze until the UI was interacted with. (#501)
• Fixed a bug where type view patterns were matching to types that they shouldn't have been. (#500)
• Fixed a bug with the asynchronous call stack building system which was causing local variables or call stacks to not update quickly, or to be incorrect. (#502)
• Fixed a bug which sometimes caused stepping operations to fail when a line's instructions stretched across a page boundary. (#503)
• Fixed a bug with invisible text in single line text views. (#498)
• Fixed some UTF-8 decoding bugs.
• Fixed incorrect local variable location information, when a procedure was the last in a compilation unit.

Linker Changes

The linker is unchanged since v0.9.18.

This is another quick follow-up release containing several fixes and improvements to 0.9.17, which was itself a quick follow-up release to 0.9.16. If you're coming from 0.9.15 or before, the 0.9.16 release notes contain most of the important information about the major changes since 0.9.15. If you have pre-0.9.16 configuration data, please back it up before upgrading to this release, if it contains important data.

The biggest change in this release is that call stack computation is now done asynchronously (in addition to other already asynchronous systems in the debugger, like process memory streaming). Fairly extensive testing and fixing of this system has been done over the past week, but a large number of systems in the debugger depend heavily on call stack correctness, and so if you experience new issues, it may be related to this change. If you do experience such issues, please do not hesitate to report them. Thank you for your patience and help in that case.

Debugger Changes

• Adjusted identifier resolution rules in the evaluation language to prefer visualizer names when used in a call expression. For example, even if you have a variable named bitmap, if you evaluate bitmap(...), it will prefer resolving bitmap to the visualizer. You can still always disambiguate with qualifiers, e.g. local:bitmap or type:bitmap.
• Adjusted the only view to allow arbitrary derivative expressions, rather than only member names. This allows custom expansions to insert rows for arbitrary expressions. These expressions are derivative from the expanded expression, meaning they can refer to the expanded expression via $, or implicitly, its member names.
• Renamed the table view to columns, and the only view to rows, since these more directly reflect the way these views are used in the evaluation visualization pipeline.
• Added an option to all text views to scroll to the bottom if the textual content changes at all. Can be used with the Output tab.
• Improved toggle switches to allow clicking and dragging to toggle many switches in a single operation.
• The debugger now records the last user file which was loaded while it was opened, and reopens that file on startup, if no user is explicitly specified. (#482)
• The debugger now unfocuses query bars (e.g. that opened by Ctrl + F in a source view) if the main view content is clicked by the mouse. The query bar can be refocused also by clicking.
• Moved call stack evaluation to occur asynchronously, so that deeper call stacks (which can be expensive to compute) do not block the UI.
• Stopped the debugger from running the default Windows message handling path for most Alt-based keybindings, which was causing a Windows beep sound to play.
• Fixed a bug where RDI files would sometimes fail to generate, resulting in no debug info being available on some runs.
• Fixed a bug which was preventing backslashes from working in file system querying interfaces correctly.
• Fixed a bug which was preventing some recursive call stacks from fully displaying in the debugger.
• Fixed a bug which prevented Space from being used as a keybinding. Bound Space by default to the Accept command (to which Enter / Return is also defaultly bound).
• Fixed a bug which was preventing conditional breakpoints from correctly being placed, if the condition expression did not evaluate when the debuggees were resumed.
• Fixed the debugger applying too much path processing, which was causing relative paths in debug info to be interpreted incorrectly. The debugger should now work much better with relative paths (e.g. produced via /d1trimfile). In these cases, the debugger may still not be able to fully compute the correct absolute paths, because this information is not stored within debug information. But once the debugger is redirected to the correct file once through the UI, it should work with relative paths correctly.
• If the debugger crashes, the message box which opens and displays the crash call stack now also allows the creation of crash dump files. Please submit these, if possible, with crash reports; it will help us to debug crashes more effectively.
• Fixed a bug which was causing text rendering to fail both when running the debugger on WINE and also on Windows 7.
• Fixed a bug where exception information inlined in source code would overlap the source code text.
• The debugger now correctly correctly interprets relative per-target stdout, stderr, and stdin paths.

Linker Changes

The linker in this release is unchanged since 0.9.17.

This is a quick follow-up release containing several fixes for the last 0.9.16 release. If you're coming from 0.9.15 or before, the 0.9.16 release notes contain much more information about what has changed recently. If you have pre-0.9.16 configuration data, please back it up before upgrading to this release, if it contains important data.

Debugger Changes

• Added a command for clearing all breakpoints. (#468)
• Extended the autocompletion UI to include a helper which shows visualizer arguments and documentation, when that visualizer is being called within an expression.
• Added the Add Function Breakpoint command back. This was initially removed because address breakpoints are now sufficiently powerful to express functions (their locations are just evaluated as expressions), but it was determined that the "Add Function Breakpoint" command, with the associated function lister, was still a useful fast-path. (#480)
• Improved enum value autocompletion, and added filtering of enum values when the . operator is used on an enum type.
• Added support for evaluating symbol names of the form a.b.c, which is a common pattern in many non-C/C++ languages (before, the debugger was treating the .s as regular dot operators in the evaluation language, with no fallback path).
• Fixed a bug where certain Delete-based or Backspace-based controls were over-deleting characters when editing text. (#464)
• Fixed a bug where editing type views would immediately apply to settings evaluations. (#475)
• Fixed a bug which reset custom keybindings every time the debugger launched. (#470)
• Fixed a crash which occurred under some conditions when editing watch expressions. (#471)
• Fixed the debugger not running when being passed the --auto_run flag. (#469)
• Fixed the debugger's treatment of .. in generated source file paths in debug information, which was preventing breakpoints from working in certain cases. (#457)
• Fixed a bug where the debugger would not display negative enum values correctly. (#455)
• Fixed a bug where using a relative project or user path would prevent paths from being correctly relativized on configuration serialization. (#477)
• Added support for arithmetic with bitfield values.
• Added path relativization for breakpoint and watch point source locations. (#477)
• Removed a default keybinding for a now-removed command (reload_active), which was preventing the rebinding of Ctrl + Shift + R correctly.
• Fixed a bug where clicking rows or hitting enter within function listers would not work, when there was no selected thread.
• Fixed a number of other small instabilities and crashes.

Linker Changes

The linker in this release is unchanged since 0.9.16 (and thus 0.9.15).

This release contains a number of major upgrades and changes to the debugger. Huge portions of the debugger have been majorly overhauled, and some portions have been rewritten. These major changes have been made to improve the debugger long-term, and many debugger systems have become more stable, but as with any set of major changes like this, instabilities and new regressions may occur. Thank you for your patience in dealing with those issues. If you happen to find some, please be sure to report them.

IMPORTANT NOTE: This release contains many changes to the configuration file format. Because the debugger is in alpha, and because the relationship between new configuration files and old is not one-to-one, I deemed it low-value to invest a lot of time in preserving all configuration data from earlier versions. Thus, only a small subset of information within old configuration files is preserved when loaded in the 0.9.16 debugger (targets and file path maps, notably). Other information will be lost. Because of this, I recommend backing up your configuration files for the 0.9.15 debugger if they contain useful data to you. That will also be useful if the new version has currently-uncovered instabilities, and you'd like to continue using 0.9.15 until those are resolved.

Below are the list of the most important changes:

Debugger Changes

• Formal integration of views (view rules) into the evaluation language. "View rules", now simply called "views", have been formally integrated into the debugger evaluation language. They now appear similar to function calls, and are expressed directly within an expression. For example, an expression dynamic_array with a view rule slice from prior versions would now be expressed as slice(dynamic_array). Alternatively, views can be expressed with similar syntax to method calls: dynamic_array.slice(). Many views can still be attached to a single expression, like dynamic_array.slice().hex() (equivalent to hex(slice(dynamic_array)). The first argument to a view is the expression to which the view should apply. Some views take additional parameters, like bitmap(base_pointer, width, height). Named parameters, required in some cases (e.g. the fmt/format parameter for bitmap), are expressed using name = value syntax: bitmap(base, width, height, fmt=bgra8).
• Support for generics in type views (auto view rules). "Auto view rules", now simply called "type views", have been upgraded to support type pattern-matching. This makes them usable for generic types in various languages. This pattern-matching is done by using ? characters in a pattern, to specify placeholders for various parts of a type name. For example, the pattern DynamicArray<?> would match DynamicArray<int>, DynamicArray<float>, and so on. ?(?) would match all function types. (#118, #345)
• Usage of the source expression within type views. Type views have been upgraded to support a larger number of possibilities. Instead of mapping to a set of views which are applied to some other expression, type views can remap the expression itself, and apply additional views. These expressions can refer to the originating expression either explicitly using the $ character, or implicitly in some cases. For instance, a type like struct Bitmap {U8 *base; U32 width; U32 height;}; can be used in a type view which maps Bitmap to bitmap(base, width, height). In this case, base, width, and height are recognized as being member names of Bitmap. This is equivalent to bitmap($.base, $.width, $.height).
• Hardware data breakpoints. Breakpoints have been upgraded to support flags for breaking on writing, reading, or execution, as well as an address range size. When used with an address location, this can be used to express hardware data breakpoints, where the CPU will break when it sees particular addresses being written to, read from, or executed, regardless of which code does it. There is a maximum limit of four such breakpoints on a processor. Theoretically, this means a limit of four per thread, but for now, the debugger only supports four global data breakpoints. In the future, we plan to allow organizing these by thread, in which case the total number of data breakpoints we support will increase.
• A new table view has been added, which allows one to define custom rules for how rows of a watch expansion are formed. The first argument a table is the expression which should be evaluated (like other views), and the remaining arguments are used to express a number of expressions which should be used to generated cells for each row in the expansion. For instance, table(my_int_array, $, $*4, $*8) would expand my_int_array, but instead of the default row structure (which displays an expression string, a value string, and a type string), three cells would be generated per row: one with the value of each element, one with that value multiplied by 4, and one multiplied by 8.
• A new sequence view has been added. This is a simple view which simply takes a single integer scalar argument n, and returns a sequence of integers, from 0, 1, 2, all the way to n. This sequence can be expanded. This can compose with the table view, to easily generate n rows, and use each integer as a value in each cell expression. As an example, table(sequence(1000), array1[$], array2[$]) would display elements of array1 and array2 in each row, side-by-side.
• The everything palette. The F1 command palette has been replaced by a substantially more powerful "everything palette" (referred to in the UI simply as "palette"), opened with the Open Palette command. This palette lists commands and allows the editing of bindings, just like the old command palette (although it now also supports searching for command bindings themselves, in addition to the original searching support for command names and descriptions). However, this palette now also lists targets, breakpoints, recent files, recent projects, settings (including tab settings, window settings, user settings, project settings), attached processes, threads, modules, functions, types, and global variables. This can be used to quickly search for a large set of possible things, and either jump to them or edit them. The old Run Command command still exists, and still presents a command palette, which is simply a special-case of the generalized palette. But this command is no longer bound to F1 by default.
• Upgraded per-tab settings. The tab right-click menu has been upgraded to show all tab-related settings, including ones specially-defined for specific visualizers (like the width and height parameters to the bitmap visualizer). The debugger UI now also supports per-tab font sizes. If a tab has no per-tab font size set, then it inherits the window's font size. Each tab's root expression is now also editable in this interface. The tab right-click menu's options also show up in the palette when the corresponding tab is focused. They can also be manually opened with the Tab Settings command.
• UI for setting fonts. The fonts which the debugger uses can now be set through settings UI (including the palette), rather than just through the configuration files.
• Support for searching system font folders for fonts. The debugger now accepts system font file names in addition to full font file paths to specify font settings.
• Per-Watch expressions and labels. Expressions inserted into a Watch tab are now stored per-tab. This makes many Watch tabs more useful, since different tabs can have a different set of expressions. Watch tabs can now also be labeled, so you can visually distinguish many Watch tabs more easily.
• Evaluation drag/drop. Evaluations in a watch tree can be dragged and dropped. This can be used to create new top-level rows in a Watch tab, or to drag evaluations between Watch tabs, or to drag evaluations to source or disassembly views and pin the evaluation to some location there. (#137, #388)
• Settings expressions. Debugger settings have been upgraded to be stored as expressions, rather than being locked to a specific value. These expressions are evaluated, like any other expression, and their evaluated value is used when the setting value is actually needed.
• Upgrades to the slice view. The slice view has been streamlined and simplified. When an expression with a slice view is expanded, it will simply expand to the slice's contents, which matches the behavior with static arrays. The slice view now also supports first, one_past_last pointer pairs, as well as base_pointer, length pairs.
• Boolean evaluation toggle-switches. The debugger now displays toggle switches as an additional visualization and editor for all boolean evaluations.
• A new range1 view has been added, which expresses bounds for some scalar value. When this view is used in an evaluation, the debugger will visualize the evaluation value with a slider, which can be used to edit the value as well.
• Merging of Watch UI with hover evaluation. The hover evaluation feature has been majorly upgraded to support all features normally available in Watch tabs. (#342)
• Added transient tabs, which are colored differently than normal tabs. These tabs are automatically opened by the debugger when snapping to source code which is not already opened. They are automatically replaced and recycled when the debugger needs to snap to new locations. This will greatly reduce the number of unused source code tabs accumulated throughout a debugging session. These tabs can still be promoted to permanent tabs, in which case they'll stay around until manually closed.
• The Scheduler tab has been removed, in favor of three separate tabs, which present various versions of the same information: Threads, `...

This release contains many smaller fixes and features for both the debugger and linker. A number of major upgrades are coming to the debugger in 0.9.16, but they'll take a bit more time; this release just contains many stability and usability improvements since 0.9.14.

Debugger Changes

• Changed string visualization to respect array sizes in an evaluation's type, making the slice view rule more useful for strings.
• Adjusted value committing rules in watch windows, to immediately commit values when editing debugger configuration (while still retaining the ability to escape and retain the old value). This fixes user experience issues where edits to things like breakpoints or targets were not being immediately recognized by the debugger (as they were not explicitly committed by the user).
• Introduced better support for an edge case in PDB generation, where a variable which was used as a return value would not have type information explicitly attached in the debug information.
• Fixed a bug which was causing the memory view to be truncated to 16 KB with active processes. (#375)
• Fixed a case where files were spuriously being displayed as out-of-date.
• Fixed artifacts relating to custom window border during resizes.
• Fixed window fullscreen and placement bugs relating to the custom window border.
• Fixed bug where panels would disappear if the window was minimized or sufficiently shrunk. (#385, #401)
• Fixed a bug in inline line information parsing, which caused breakpoint traps to be placed at an invalid instruction addresses when placed in inline sites, generally in release builds.
• Fixed some cases where spurious exceptions were being generated, due to "spoofs" (bogus return addresses the debugger writes into a call stack, in order to step over potentially-recursive calls).
• Fixed a bug where the debugger would freeze when editing certain expressions. (#362)
• Fixed a crash with assembly-style register offset dereference evaluations (e.g. [rdx+0x40]). (#378)
• Fixed a hang when entering long strings for target or breakpoint information. (#387)
• Fixed a crash in the debug info fuzzy searching system. (#363)
• Fixed a crash or invalid state case when a debug info tab (e.g. Types, Procedures) was visible upon starting a debugging session. (#420)

Linker Changes

• Fixed a crash when linking against same DLL statically and dynamically.
• Fixed a bug in global symbol table sorter which prevented debugger from looking up certain symbols.
• Reduced overall memory usage.
• Added support for /FUNCTIONPADMIN.
• Fixed a crash when emitting base relocations for 32-bit pointers.
• Added /RAD_SHARED_THREAD_POOL which tells linker to use a shared semaphore to utilize better system resources when spawning many linker instances at the same time.
• Added /RAD_WRITE_TEMP_FILES to prevent leaving corrupted files on disk when linker is terminated mid write, files are renamed after all writes successfully finish.

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.

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)

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.

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.