A small update which enables future improvements has been released.

• Switched the solution file format to .slnx
• Renamed Reko.Core.Types.Pointer => Reko.Core.Types.PointerType
  which harmonizes with the other *Type classes.
• Use ExpressionEmitter.ExtendS and .ExtendZ to express sign-
  and zero-extension, rather than arbitrary Convert calls which ended
  up being inconsistent.
• Introduced addc/subc intrinsics, and replaced
  sequences IAdd(IAdd(a, b), C) and ISub(ISub(a, b), C)
  with intrinsics __addc(a, b, C) and __subc(a, b, C) to simplify
  analyses.

A new Reko release sees the world! The changes are not large but worthy nevertheless:

• Support for the NEC V20 architecture, similar to the x86 but with some different instruction encodings.
• Support for Intel Itanium IA-64 architecture.
• Introduced the concept of "RegisterBanks" in the Reko codebase.
• Refactored the command-line driver so that it doesn't use "string-based typing".
• A TimeUtilities used for rendering times.
• Performance improvements in LongAddRewriter analysis resulted in 25% wall-clock reduction on some binaries.
• Added user interface to allow users to modify the platform Reko uses decompilation.
• Migrated code to use the new IMemory interface.
• Added support for handling int instructions in the X86 emulator.
• Reduced memory footprint of shingle scanner
• Improved selection gestures in the MemoryControl.
• Avalonia driver now has feature-matched ImageMapControl, ImageMapView, ad VisualizerControl

Bug fixes:
#1287, #1363 #1365 (partial), #1364

This maintenance release consists mostly of bug fixes, but also contains some new features. Some of these are:

• Added support for Renesas RxV2, Seiko-Epson C33 CPU, Infineon M8C, CSR Kalimba, Motorola 88k, and National Semiconductor NS32k processor architectures. Reko now supports 97 processor architectures!

• Made it possible to override the operating environment from the command line using the --env <environment-name> switch.

• Consolidated some of the architecture implementations into fewer .csproj files. Currently the Reko solution is around 150 .csproj files, and reducing this number improves the compilation times a bit.

• Changed ConditionOf to require a data type. Previously ConditionOf always had a data type of (8-bit) Byte , but not all architectures
  have 8-bit processor status registers. In addition, many invalid assignments were being generated as a result.

• Recognize SysV intrinsic functions. GCC libc has low-level functions for long multiplication (__muldi3), point addition (__adddf3) etc. Reko now recognizes these and adjusts parameters accordingly.

• Added NanoO32 calling convention to the MIPS architecture.

• Refactored MockGenerator so that it uses a IMockIdentifierWriter to render variable definitions according to whether a ProcedureBuilder or an SsaProcedureBuilder is being used to generate C# code. This helps in generating test cases quickly from crashes for easier debugging.

Thanks to @throwaway96 for his contribution to this release!

A new minor release of Reko is available. The main focus of the release has been to provide better XML documentation, which has been requested by users.

• XML documentation is now available for all classes in the Reko.Core and Reko.Decompiler assemblies. In addition the build now treats missing XML documententation on types and type members as compiler errors. This will enforce a higher standard of documentation moving forward.

• The Reko.Decompiler.Runtime Nuget now includes the XML documentation.

• Support for disassembling and lifting PDP-1 machine code was added. I'm fairly confident that Reko is currently the only decompiler supporting this venerable architecture!

• Added support for OKI NX8/200 and NX8/500 architectures.

• Added support for Intel's APX instruction prefix.

• General code cleanup and fixes. Removed many classes that have become obsolete over the years.

• @smx-smx provided a fix for a crash in the ELF loader when loading ELF files with unknown ABIs.

• Fixed the command line driver to better handle command line arguments when disassembling raw images.

• More work on ScannerV2 to handle delay slots correctly on Sparc, Mips, and PA-RISC architectures.

• Added support for loading little-endian 64-bit PowerPC ELF images.

• Eliminated the OutArgumentStorage class. This class was confusing and hard to use. It has been replaced by the new Outputs collection on FunctionType which tracks
  the registers used for returning values from procedure calls.

• The new method ITestGenerationService.GenerateUnitTestFromProcedure can now generate compileable C# code when crashes occur. This will greatly improve handling user-reported problems.

Special thanks to @smx-smx for troubleshooting various ELF loading issues.

Reko version 0.12.0 has been released. It has the following features and changes:

• The solution has been upgraded to .NET 8. Downstream projects using the
  Reko.Decompiler.Runtime NuGet and running on earlier versions of .NET will
  have to upgrade to .NET 8 or later to use this version.

• The Expression class was refactored to an interface. Doing this allowed the
  refactoring of the Address class to a struct. Similarly, the MachineOperand
  class was refactored to an interface. This allowed Reko.Core.Constant and
  Reko.Core.Address to implement the MachineOperand interface. The Address
  type is one of the most heavily used types in the Reko project, and making it
  a struct measurably improves Reko's execution time and memory consumption
  performance.

• Added support for the following processor architectures:

  • DEC PDP-7
  • Panasonic MN103
  • NEC SX-Aurora
  • Maxim MaxQ
  • Beyond BA
    As usual with new architectures, they will be rough around the edges until
    they get attention. The Reko project greatly appreciates volunteers who can
    provide sample binaries to stress these new implementations.

• Scanner V2 improvements. In the background, Reko is preparing for a big
  change in how it processes input files. Regrettably, time constraints are
  slowing down the progress in this direction. Once completed, Scanner V2 will
  be the main feature of Reko's v1.0 release.

• Octal constants with a "0o" prefix. This is not compliant with C/C++.
  Future versions of Reko will use the normal "0" prefix for octal numeric
  literals.

• Support was added for user-provided Reko plugins by implementing the
  Reko.Core.Plugins.IPlugin interface, as documented here.

• Support for BBC Micro DFS archives added

• Various other small fixes.

Special thanks to @smx-smx for his assistance in repairing broken CI builds.

A long overdue release has finally emerged. The changes are mostly incremental improvements of both the decompiler outputs and of the decompiler code base itself. Some highlights are:

• Rearchitecting of the ILoader/Loader interface and class.

• Introduced the IBinaryImage interface that abstracts a binary image. The intent is to add a dump subcommand to the Reko command line client to make browsing of binaries convenient.

• added support for WASM 3.0 instructions.

• added support for MN103, M16C, Telink TC32, and Angstrem KR1878 CPU architectures

• added support for most of C-Sky floating point instructions.

• added support for CP/M LBR archives

• Reimplemented the handling of the CP/M BDOS dispatcher correctly.

• All Z80 instructions have rewriters now.

• Support for VAX Unix system calls

• Fixed many bugs in the 6502 emulator

• added support for calling MS-DOS and DPMI INT services from Win16Platform

• added support for long constant fusion to all the major RISC architectures. The disassembly of (load-high / load-low) instruction pairs is now easier to read.

• improved handling handling of procedures returning flag bits

• added support for the [[reko::segment]] attribute in C/C++ header files

• added support for VAX a.out object files

• implemented missing logic in WildPatternMatcher + re-enable unit tests

• refactored data flow analysis classes as implementations of the IAnalysis<> interface * Refactor core Analysis classes to Reko.Core so that architecture-specific analyses can be implemented without adding dependencies to Reko.Decompiler assembly.

• decompiled procedure arguments are ordered according to the ABI. Reko also tries to detect which ABI was used to compile procedures, if many ABIs are available on a particular platform.

• better sequencing of VLIW instructions (see Hexagon implementation for details)

Thanks to @smx-smx and @nemerle for their contributions!

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.

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.

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!

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.