Version 0.11.5

This Reko release contains a variety of new features and improvements.

New contributor @gregoral made huge improvements to Reko's Risc-V support:
added decoders and rewriters for many new Risc-V instructions both unprivileged
and privileged, fixed many bugs in existing instruction decoders, and provided
a new instruction renderer for the architecture. Reko's Risc-V disassembly output
can now be assembled by other toolchains -- it's round-trippable.

Contributor @throwaway96 continued improving support for the mysterious
AEON architecture, and various enhancements in the Reko implementation of the
C preprocessor. Now there is a #define symbol __REKO_DECOMPILER__ that is
set to 1 when parsing C header files with Reko.

Progress on the platform-indepentent Avalonia GUI is slow but continuous.
The project was moved to Avalonia 11 from the previous 0.10 verson. A major
milestone was reached when the MemoryControl and TextView classes were finally ported to Avalonia.
The only remaining custom controls remaining, the VisualizerView and the ImageMapView
controls, are scheduled to be completed in the coming weeks. The Avalonia user interface
is soon going to reach feature parity with the Windows Forms interface.

Contributor @ptomin continued improving Reko's type inference engine. We are
reaching a point where limitations in the general strategy of Reko's type inference
are hindering progress. An alterative type analysis, based on subtype constraints, is
being researched.

Contributor @smx-smx labored on the build system with various performance
improvements and bug fixes in preparation for support of .NET 8

Some other changes:

• Reko now reads PE executables looking for the PE debug directory.
• Very rudimentary PDB reading support is present. It's a starting point
  for extracting symbolic information from binaries with associated PDB
  files.
• Fixes to the WASM rewriter.
• Much improved support for COFF and OMF file formats
• All known CR16c instructions now supported.
• All known AVR32 instructions now supported.
• Support for distingushing 16- and 20-bit MSP 430 instruction sets.
• Added support for C-Sky architecture.
• Stub implementations of Zilog Z8000 and eZ8 architectures.
• Corrected behavior for Sparc SAVE/RESTORE instructions.
• Introduced a new IMemory abstraction that hides the details
  of segmentations. New code is expected to using this new interface rather
  than manually looking up addresses in SegmentMap.
• Added support for Architecture aliases. For instance, the X86 architecture can
  be referred to as i386 or x86.
• Support for the PalmOS platform, including handling A-line trap calls
  on that platform and MacsBug symbol support.
• New packing script for LzExe 0.91, written wholly in OllyScript and using Reko'scheduled
  X86 emulation.
• Handle '*' in *printf format strings.
• Introduced IFunctionalUnit abstraction to handle SIMD instructions in a
  coherent way.

Thanks to @gregoral, @ptomin, @smx-smx, and @throwaway96 for their contributions and dedication.

Version 0.11.4

Another few months, another Reko minor release. Development continues in various directions.

In the architecture department, support was improved for various architectures, especually AEON and H8. X86 string instructions (rep movsb etc) are replaced by their C library equivalents (memcpy etc) (contributed by @ptomin). Bugs in the X86 and 6502 emulators were fixed.

Reko's C parser and preprocessor in particular received some attention. Nested #if/endif statements are now handled, various stability contributions were provided by @throwaway96.

The command line executable was changed from decompile.exe to reko.exe. It was refactored to support sub-commands. Currently those are

• reko disasseble, which loads a file and disassembles its contents
• reko decompile, which in addition performs data, type and structure
  analysis.
• reko assemble, which allows users to assemble source files.
  If no subcommand is specified, Reko will default to decompile.

Underneath the covers, the Reko decompiler is undergoing a slow but seismic refactoring. Progress was made in the new Scanner, which already is about 4x faster than the existing implementation. The Analysis phase was also refactored (via the new SccWorkerCoordinator class) to make it possible to run it multithreaded in the future. Across the board, global mutable state is being replaced with immutable data structures, or judiciously kept thread-safe by using appopriate critical sections and locks.

Reko will start understanding SIMD instructions better with the introduction of the SimdIntrinsic class.

The user interface is also seeing a slow but seismic overhaul. The Windows Forms GUI is refactored so that creating side-by-side interface elements in parallel with the Avalonia GUI is smoother. Various small GUI enhancements have been added, like support for flipping through architectures in the low level view. This feature allows the user to flip through Reko's architectures and see the results in the DisassemblyView. The new CallGraphNavigatorView improves the navigation of the decompiled program's call graph.

• A new unpacker for PKLITE v1.12-1.20
• Support for various [[reko::...]] attributes in header files, especially
  [[reko::characteristics]].
• Partial support for the OpenVMS platform.
• The pseudoregister %continuation is used to reify the return address of
  a called Procedure.
• Improved support for LE binaries.
• M68k fixed (with thanks to @gbody)
• More MS-DOS INT 21h services defined.
• Support translation of WASM IR into Reko IR.
• Added support for calls-respect-abi heuristic.
• Display the currently selected address range in the status bar (#1232)
• Added the Padauk PDK13,PDK14 and PDK15 instruction sets.

Thanks to @gbody, @mjunix, @ptomin, @smx-smx, and @throwaway96 for their contributions and dedication.

Version 0.11.3

The largest new feature of this release is the support for disassembling, rewriting, and emulation of instructions of the AEON (or BEON, or R2) processor. It is the first architecture in Reko implemented with no manual -- we've been unable to find the instruction set described in a publicly available resource. Instead, thanks to the hard work of @throwaway96, most of the instruction set has been reverse engineered. Many thanks for this great effort!

@smx-smx improved the stability of the build and eliminated redundant compilations of the build tools, resulting in a faster build overall.

Some other features added are:

• Introduced the notion of Unlikely instructions: instructions that while well-formed are unlikely to be present in a "normal" program. Reko can optionally be instructed to treat such unlikely instructions as invalid

• The user may also optionally instruct the Reko to treat protected/system instructions as invalid.

• Since the move to .NET 6, Reko's custom 16-bit IEEE float implementation became redundant and was removed.

• The GUI client now supports multiple scanning heuristics.

• Support for user-defined segments was added.

• Improvements in handling of varargs procedures.

• Switch statements for MIPS, MIL-STD-1750A and Intel 8051 improved.

Thanks to @throwaway96 and @smx-smx for their contributions and support!

Version 0.11.2

My, has it been that long already since last release? Here's an overview of what's happened since.

The Reko solution was moved to .NET 6. As expected, performance and memory footprint was impoved.

The partially completed, still very much work-in-progress Avalonia development branch was merged into master. Moving forward, any changes in the GUI components will be mirrored in Windows Forms and Avalonia. For instance, the new Base Address finder tool window now exists for both GUI platforms.

Another big push is the move to support multithreaded scanning and analysis. Today, Reko uses only a single CPU thread for its CPU-intensive work. Partitioning the work as mutually independent workloads across multiple threads should see a great improvement in execution time. In order to accomplish this, several classes have been altered to only use read-only interfaces to global data, to prevent data race conditions. The work to eliminate globally visible mutable state continues.

Several new metadata annotations were added ( with the gentle prodding of @Elthial). You can now annotate C functions with the [[noreturn]] , [[reko::arg(seq...)]], and [[reko::address]] attributes.

Other bits and bobs:

• Improvements to ArgumentGuesser to handle call sites where Reko can't prove the target address.
• The codebase's namespaces were refactored to make them more easy to understand.
• Added or improved support for the following architectures: ARM, AArch64, BlackBin, Fujitsu F2MC16FX, MIPS, PDP-7, PowrPC, RiscV, MicroBlaze, SuperH SH2..SH4A, TriCore and x86 EVEX
• Support for discovering and parsing x86 and x86-64 MSVC RTTI .
• Fix calculation of alignment of unions (@ptomin)
• Refactored intrinsics for improved performance
• PharLap "MP" Exp file loader (#1169)
• MzExe: allow reading PEs without IAT (@smx-smx)
• Improved support for XEX executables (@smx-smx)
• Handle '*' in *scanf format strings.

Special thanks to @ptomin and @smx for their dedication and contributions.

Version 0.11.1

This maintenance release provides minor enhancements and bugfixes, including:

• More ARM32 rewriters.
• More uses of generic IntrinsicProcedures.
• Replace recursive SccFinder with an non-recursive implementation.
• Initial support for Terse Executable format.
• Don't try tracing into nonexecutable code.
• Ctrl+0 resets the zoom level of the Graph Viewer
• Many more PowerPC instructions supported
• C parser issues reported by @smx-smx
• Make SSA analysis use bit-accurate analysis for stack variables.
• Multithreaded robustness.

It also has some refactorings and new classes, setting the stage for a future refactoring of the Scanner:

• New RtlSwitch subclass of RtlInstruction
• Support for platform-specific patterns for procedure entries.

Version 0.11.0

This release of Reko has breaking changes in interfaces and classes, and completes the move to .NET 5.0. Many classes were also moved to different namespaces: you'll need to recompile your project. The file loading code was refactored heavily to be easier to use and to support the reading of files stored in (potentially deeply nested) archives. Many fixes were made in the AArch64 rewriter (with gentle prodding from @rfalke).

Some other new features are:

• Wasm files can be loaded and disassembled. A rewriter will materialize in a later release.
• Reko Gui is asynchronous. This will help the ongoing port to Avalonia.
• Stack variable references that escape to other procedures are now tracked (courtesy of @ptomin).
• The new ByteTrie class can be used for pattern matching.
• Added support for PDP-10 architecture. The PDP-10 is word-addressable, has 36-bit words, 18-bit addresses, and variable sized bytes, all of which contrast vividly with present day 8-bit-based architectures.
• The MemoryControl displays sizes other than bytes. This accommodates PDP-10, Microchip PIC, and Mil-Std-1750A.
• Intrinsic procedures can now have generic parameter and return types.
• Added initial support for COFF files.
• Adapted OllyLangInterpreter to other architectures than X86.
• Added m6502 emulator, c64 emulator.
• Various CI improvements and fixes. Also, Reko now builds on ARM64! (courtesy of @smx-smx)
• Added support for constants larger than 64 bits.
• Support for reading TAR and AR archives.
• Support loading files from arbitrarily nested archives.
• Rewrote the loader so it is much easier to use (and understand).
• Extended C parser to handle more GCC attributes.
• Support for Sanyo LC8670.

Thanks to @nemerle, @ptomin, @shandianchengzi, @slartibardfast, and @smx-smx for their time and contributions to the Reko project!

Version 0.10.1

This maintenance release moves Reko from .NET Core 3.1 to .NET 5.0, resulting in some performance gains.
It also fixes the MSI installers for Windows, which had several issues (including #1066 and #1067). Special thanks to @smx-smx for his work on his CI integration work.

• The Reko build system now assumes C# 9.0
• Crude support for #define directives in the Reko C parser
• Overhaul of PA-RISC and HP SOM loader
• The command line driver --version switch displays the git hash used to build the binary.
• Improvements in AArch64 disassembler and rewriter (with @rfalke as a driving force)

Version 0.10.0

In this Release, the Reko source code has been moved onto .NET Core. The Windows Forms GUI and command line interpreter are now hosted on .NET Core 3.1, while the Reko plugins have been ported to .NET Standard 2.1.

The Reko C parser was extended to handle more platform specific dialects of C. Special C++-style attributes can be used to specify metadata in C format, rather than in XML format.

A Python scripting engine and API were added by @ptomin. Scripts written in Python can be written to analyze a loaded image file.

• Support for the Nintendo Gameboy, Altera Nios-II, and C166 architectures.
• Support for PowerPC MacOS; improved support for Class M68k MacOS.
• Support for Xbe, eCoff, PEF, and XCoff image file formats.
• MS-DOS specific improvements were contributed by @blindmatrix.
• The Tools > Hex diassembler window provides a quick way to disassemble hex-encoded bytes

Under the hood, some major refactorings were done to rationalize the sprawling Reko.Core namespace. The build system was revamped by @smx-smx, centralizing various ad-hoc tools. Support for C# 8 nullable has been introduced in most projects.

Thanks to @blindmatrix, @claunia, @gbody, @ptomin, @SamB, @smx-smx, @starword for their time and contributions to Reko.

Version 0.9.3

This is the last time Reko is released for .NET Framework and Mono. Future releases will be based on .NET Core and .NET 5

The release consists of minor feature enhancements and bug fixes.

• Initial support for IA-64 and v850 support
• Support for the MIL-STD-1750, XCore-200, CompactRisc, MCore and Hexagon architectures
• Rewrite Reko's MemoryArea abstraction to support non-byte-oriented archictectures (like Cray YMP and MIL-STD-1750)
• As usual, more x86 rewriters (with thanks to @smx-smx)
• Improved Sparc, zSeries, and Risc-V disassemblers
• Fuse adjacent memory accesses
• x86 and GUI support for specifying separate architecture models.
• Unpacker script for Exepack 3.60 et al.
• Loader for preprocessed C headers, making it possible to use such headers as metafiles in Reko projects (with thanks to @ptomin)
• User-supplied labels (#987)
• Register Values dialog (#950)
• Support for the TekHex and LDM text file formats
• Support for Unicos binary executables.
• Support for PharLap DOS Extender executables (with thanks to @gbody)

Thanks to @gbody, @claunia, @ptomin and @smx-smx for their time and contributions to Reko.

Version 0.9.2

This release of Reko is dedicated to the memory of contributor Christian Hostelet, who passed away this year. He extended Reko with support for MicroChip PIC and was instrumental in implementing support for specifying processor models in the Reko GUI.

This release is the first one that publishes the Reko runtime components (architectures, image loaders, platforms etc) as a separate NuGet package, available at https://www.nuget.org/packages/Reko.Decompiler.Runtime. Programmers can now use the Reko toolchain in their own projects to load files. One implication of publishing a NuGet is that semantic versioning needs to be observed (https://semver.org/). Since Reko is still very much a work in progress, this doesn't impact the project heavily yet. However, now that external projects have dependencies on Reko, we will try to make their maintainers' lives easier by being scrupulous about version numbers.

The OllyScript interpreter was refactored and extended to support X86 segmented addresses. This makes it possible for Reko to use a simple OllyScript to unpack binaries, rather than having to hand-write unpackers in C#. The X86 emulator was also augmented to support segmented addresses. The PK-Lite MS-DOS EXE unpacker uses an OllyScript file to accomplish its task.

Internally, a new Convert expression was introduced to remove the amiguity inherent in the Cast expression. The latter assumes the types of the cast expression is known, which in decompilation is not always true. Convert explicitly states what type is being converted from and what type is converted to. Adoption of Convert resulted in many code improvements, especially around handling of floating-point literal values.

The rendering of global variables is now much improved (with thanks to @ptomin).

For developers, the new ITestGenerationService supports the generation of unit tests when a machine instruction couldn't be decoded or rewritten. It generates a text file in the decompiler output directory, which users can submit in an error report.

The Reko intermediate language is moving toward becoming "round-trippable". The intent is to reach a point where Reko can read in IR in a persisted format (like text or binary) faithfully.

A special thank you to @rfalke, who reported many issues when running his decompiler testing project: https://github.com/rfalke/decompiler-subjects. The RekoSifter tool was used to discover many issues in the Reko disassemblers (with thanks to @smx-smx for his work).

• Support for AVR32, 64-bit SPARC, 65816, Risc-V, Hitachi H8,
• Support for the SNES, original Xbox plaforms
• Support for the SREC, Xbox XBE image file formats
• Support for MASM and NASM style disassembly (suggested by @tgiphil)
• Support loading C64 PRG files (#928)
• Implemented missing instruction decoders and rewriters for architectures with large instruction sets (ARM32, AArch64, X86)
• Improved support for MachO binaries
• Initial support for loading WASM files, still a work in progress.
• The command line client has a progress indicator (suggested by @smx-smx)

Thanks to @blindmatrix, @ptomin, @rfalke, and @smx-smx for their time and contributions to Reko.

In memoriam - Christian Hostelet (1955-2020).