Softpedia >Windows >Programming >Debuggers/Decompilers/Disassemblers >Reko Decompiler >  Changelog

Reko Decompiler Changelog

What's new in Reko Decompiler 0.11.5

Mar 22, 2024
  • 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.

New in Reko Decompiler 0.11.4 (Sep 4, 2023)

  • 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.

New in Reko Decompiler 0.11.3 (Jan 5, 2023)

  • 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.

New in Reko Decompiler 0.11.2 (Dec 5, 2022)

  • 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.

New in Reko Decompiler 0.11.1 (Apr 7, 2022)

  • 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.

New in Reko Decompiler 0.11.0 (Mar 14, 2022)

  • 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.

New in Reko Decompiler 0.10.1 (Sep 21, 2021)

  • 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
  • he 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)

New in Reko Decompiler 0.10.0 (Aug 16, 2021)

  • 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.

New in Reko Decompiler 0.9.3.0 (Feb 8, 2021)

  • 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)

New in Reko Decompiler 0.9.2.3 (Oct 2, 2020)

  • 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)

New in Reko Decompiler 0.9.1.0 (Apr 17, 2020)

  • This is a minor release, but with a lot of new small features and fixes.
  • A noteworthy new feature is Reko's ability to automatically place decompiled procedures into different files, based on a OutputFilePolicy. An OutputFilePolicy decides into which files procedures should go, based on criteria like segment name, address offset within a segment etc. Future work will allow users to customize the placements on a per-procedure basis.
  • The project has partially completed moving .csproj files to the new .NET SDK format (issue #748). Most files are now building to the netstandard2.0 target framework. Progress is stalled due to the complex Reko build process. If you're interested in helping us get ready for .NET 5, contact the Reko team at https://gitter.im/uxmal/reko.
  • Initial support was added for the following CPU instruction set architectures:
  • Motorola 6809
  • WE32100
  • LatticeMico32
  • ARC, ARCompact
  • Mips16e
  • Other noteworthy new features include:
  • Support for 16-bit OS/2 executables (with thanks to @claunia)
  • Introduced rudimentary LE/LX executable support (with thanks to @claunia)
  • Introduced support for Nintendo Switch (with thanks to @smx-smx)
  • Enhancements to Xbox370 XEX executable loader (with thanks to @smx-smx)
  • Apply relocations to MacOS classic A5 world (with thanks to @gbody)
  • Implement finding ASCII and UTF-8 strings (with thanks to @ermshiperete)
  • Stability and bug fixes in SSA transform (with thanks to @ptomin)
  • Introduced 6502 emulator for handling C64 unpackers.
  • Introduced support for CodeView debugging information.
  • Introduced support for Commoder 64 T64 file format and MorphOS binaries.
  • Introduced OMF library loader
  • New AssembleAt method will allow patching of code with assembler language
  • Handle Windows VxD dynamic linking fixups
  • Fixes to i8051, ARM, M68k, PowerPC, X86 disassemblers and rewriters
  • Changes to the C parser to handle Microsoft and IBM-specific extensions (__far, __near, __pascal, etc)
  • Support for Microsoft Binary Format (5-byte floating point numbers)
  • Generalized OllyDbg support to handle non-x86 architectures.

New in Reko Decompiler 0.9.0.0 (Nov 9, 2019)

  • The main feature of this release is the long-awaited reworking of the analysis phase of the Reko decompiler. The slow and inaccurate interprocedural register liveness analysis was replaced by a novel analysis based on the strongly connected components (SCC's) of the call graph. The SCC's, which most of the time consist of a single procedure, are converted to SSA form earlier now.
  • In addition the classic Cytron et. al SSA construction algorithm, which requires the eager calculation of the immediate dominator relation of the basic blocks in the procedures, was replaced with a simpler S algorithm described in "Simple and Efficient Construction of Static Single Assignment Form" by Matthias Braun et al. The SSA algorithm has been augmented to perform lazy register / stack variable alias analysis, which turned out to be more efficient than the old register alias analysis phase.
  • The handling of 'hell nodes' has received focused attention. Hell nodes are indirect calls without associated function type metadata. Previously Reko was pessimistically assuming the worstthat all registers are live in and live out. Several heuristics have been applied to 'tame' the hell nodes to make the resulting output manageable (with many thanks to @ptomin).
  • Many other improvements to the data flow analysis were incorporated in this release as well. The results are improved source file outputs.
  • Initial support was added for the following CPU architectures:
  • Blackfin
  • Cray YMP
  • OpenRISC
  • MicroBlaze
  • PA-RISC
  • RL-78
  • Progress is hampered by the lack of good sample binaries with which to train the decompiler. Please contact us if you have any such binaries available.
  • Changes were also made in the output folder structure, and binary resources (like embedded icons and menus) are now extracted. (with thanks to @Cairn23)
  • Thanks to @Cairn23 and @gbody for their contributions. Special thanks go again to @ptomin and @smx-smx for their code, time, and dedication.

New in Reko Decompiler 0.8.1.0 (Mar 17, 2019)

  • It's been a long time since the last release, but a lot has been happening in Reko-land. This release contains:
  • Support for PIC16 and PIC18 architectures (with thanks to @chostelet)
  • Much better support for Intel HEX files (with thanks to @chostelet)
  • Moved to C# 7.2, .NET Framework 4.7, and NUnit 3.0 (with thanks to @chostelet)
  • Improvements in indirect call handling (with thanks to @ptomin)
  • Support for adding persistent user annotations / comments (with thanks to @ptomin)
  • Backward propagation of stack pointer from procedure end recovers more frame-based variables (with thanks to @ptomin)
  • C parser improvements (with thanks to @ptomin)
  • Improvements in MacOS classic binaries (with thanks to @gbody)
  • Handled compressed A5World segments in MacOS classic binaries (with thanks to @gbody)
  • Refactored Reko.Gui.dll to remove Windows Forms dependencies in preparation for GUI front end independence (with thanks to @smx-smx)
  • Xbox 360 XEX Loader (with thanks to @smx-smx)
  • PowerPC VMX instructions (with thanks to @smx-smx)
  • Improvements in X86 disassembler robustness (with thanks to @smx-smx)
  • Generation of for-loops from while- and do-loops (with thanks to @rfalke)
  • Initial support for ARM AArch64, IBM zSeries, Intel 8051, Motorola 6800, MSP 430, Risc-V, SuperH, TMS 7000, and XTensa architectures.
  • Support for the PowerPC 750 instruction set.
  • Improved disassembler performance about 20% across all architectures.
  • Improvements in shingled scanner heuristic, reducing false positives.
  • Much better support for indirect jump / call target resolution.
  • Improved handling of ELF PLT entries.
  • Fusion of MIPS-style unaligned loads and stores.
  • Support for 16- 80- and 128-bit IEEE 754 floating point numbers.
  • Moved from Rhino.Mocks to Moq mock framework.
  • Support for more than one architecture per decompiled binary.
  • Support for platform-specific memory maps.
  • Memory visualizer control shows heat maps of binaries.
  • Command line switch --scan-only.
  • Added NamingPolicy classes to abstract automatic naming of variables, procedures, and types.
  • Lots and lots of small bug fixes.

New in Reko Decompiler 0.8.0.0 (Mar 10, 2018)

  • The major feature in this release are the changes to Reko to support the use
  • of native code disassemblers, and potentially any other low-level libraries
  • that may prove beneficial such as symbol parsers and code emulators. The
  • Reko build system was modified to allow the compilation of C++ code that interfaces
  • between low-level libraries and the other, managed parts of Reko. The immediate
  • benefits of these changes are the much improved support for the ARM processor
  • architecture and (finally) the possibility of running Reko in 64-bit mode.
  • This is the first release where a 64-bit MSI installer is available for Windows
  • users. Non-Windows users can now choose whether to build a 32- or a 64-bit version
  • of Reko. With the expanded address space, the 64-bit version will be able to handle
  • larger binaries than the 32-bit version.
  • Another area of large improvements is the generation of structured C code. Reko's high-level
  • output is now much improved.
  • Some other changes of note:
  • Improved TRAP and A-line instruction support for MacOS Classic.
  • General improvements for MacOS classic and M68k support.
  • Impelemented a Pascal parser to handle MacOS MPW header files.
  • Improved support for Intel HEX files.
  • Support for DEC Alpha and AVR8 architectures.
  • Support for many more x86 SSE instructions, initial support for AVX instruction types.
  • Finally merged PR from @Lukas-Dresel to improve support for MIPS-64.
  • Parallelized regression suite script across processes; this sped up the output by a factor of 5.
  • Support for Borland symbol information.
  • Moved project to C# 7 and .NET framework 4.7.
  • Fixed bugs in the Type inference affecting recursively defined types.

New in Reko Decompiler 0.7.2.0 (Oct 25, 2017)

  • Refactored the CallingConvention classes
  • Improvements to code structuring (thanks to @ptomin)
  • Handle 68k PE executables (yes, really!) (thanks to @smx-smx)
  • Improved MIPS code rewriting, with focus on LWL/LWR, SWL/SWL instructions
  • Added Appveyor as a CI provider
  • Impovements in the Reko build process
  • Bugfixes

New in Reko Decompiler 0.7.1.0 (Oct 25, 2017)

  • Added partial support for Atari-TOS binaries
  • X86-64 ELF support for locating 'main' program.
  • Replaced Win32-specific code in OllyDbg script handler
  • Added --time-limit command-line switch to force termination after a certain time interval
  • More x86 and M68k instruction rewriters
  • Handle MIPS SWL/SWR and LWL/LWR instruction pairs
  • Support for displaying absolute address when PC-relative addressing expressions are encountered
  • Support for Borland C++ mangled identifiers
  • Improved NE EXE image loader

New in Reko Decompiler 0.7.0.0 (Jun 2, 2017)

  • The big feature of this release is the adaptation and implementation of the shingled disassembler and procedure detection algorithms described in the papers "Shingled Graph Disassembly: Finding the Undecidable Path" by Richard Wartell, Yan Zhou, Kevin W.Hamlen, and Murat Kantarcioglu (https://www.utdallas.edu/~hamlen/wartell13techrep.pdf) and "Compiler-Agnostic Function Detection in Binaries", by Dennis Andriesse, Asia Slowinska, Herbert Bos (https://syssec.mistakenot.net/papers/eurosp-2017.pdf). A clone of the source code from the latter is located here: https://github.com/uxmal/nucleus.
  • These optional analyses vastly improve Reko's discovery of executable code, at the cost of increased memory and time consumption. Because of the cost, they must be explicitly requested. In the GUI client, this is done by right-clicking on a loaded program node, selecting the Properties menu item, switching to the Scanning tab and selecting "Shingled scanning". From the command line, the following incantation will do the job
  • Some other goodies are also part of this release:
  • Added support for the Super-H, TLCS-90, and TLCS-900 processor architectures.
  • Added support for the SEGA DreamCast, and NeoGeo platforms
  • Added a front end that can load LLVM .ll files and transpile them into Reko IR. Special thanks for @mewmew for his assistance
  • Added an Intel HEX file front end.
  • The usual large number of bug fixes

New in Reko Decompiler 0.6.1.0 (Aug 25, 2016)

  • Implemented a general varargs processing mechanism, and specific instances for standard C printf and scanf function families, as well as the Py_BuildValue function from the Python runtime.
  • Early support for dealing with indirect function calls.
  • Improved ELF support for x86, x86-64, MIPS, PowerPC, ARM, and Sparc
  • Improved PE support for x86, x86-64, MIPS, and ARM
  • Added support for lifting more instructions in x86, M68k, VAX, Sparc, MIPS, Z80 architectures.
  • Beginning support for signature libraries.
  • The cancel button actually works now!
  • Support for "No decompile"
  • General bugfixes

New in Reko Decompiler 0.6.0.0 (Apr 19, 2016)

  • Combined code and low-level viewer, to allow users to compare Reko's output with the original binary.
  • A graph viewer, to help users to visualize procedure call graph
  • Image map view shows an overview of the image bytes as pixels
  • Allow user to specify the encoding used for text when displaying character data
  • New reko configuration and project file formats
  • Improvements in user-specified data types
  • More MIPS instructions supported
  • SPARC support greatly expanded
  • Added initial support for DEC VAX processor architecture
  • Support for SEGA Genesis platform added
  • Much better support for ELF binaries, both executables and relocatable object files
  • Refactored central ImageMap class to support binaries with large address space "gaps"

New in Reko Decompiler 0.5.5.0 (Jan 9, 2016)

  • A belated Christmas present! With a shout out to @ptomin and @nemerle, with gratitude for their contributions.
  • Shingled disassembler implementation, in preparation for heuristic discovery of code.
  • Support for WinCE / MIPS
  • Improved data type inference
  • New project file format supports saving of more user options.
  • Better support for MonoDevelop
  • Many many small bugfixes

New in Reko Decompiler 0.5.4.0 (Nov 2, 2015)

  • Support for renaming decompiled procedures and changing their signatures. Changing signatures will affect following decompilation stages, as expected.
  • Support for the Windows - OS/2 New Executable format (NE EXE)
  • Implemented continuous integration using Travis CI

New in Reko Decompiler 0.5.3.0 (Sep 15, 2015)

  • Support for the MIPS architecture, and MIPS support in the PE and ELF image
  • format
  • TextViewer now supports free selection of text.

New in Reko Decompiler 0.5.2.0 (Aug 27, 2015)

  • New structural analysis inspired by "Native x86 Decompilation Using Semantics-Preserving Structural Analysis and Iterative Control-Flow Structuring" (Schwartz, Lee, Woo, Brumley) yields much improved structured C-like code; the implementation itself is much simpler than the previous one.
  • C2Xml tool understands C++11 attributes, in particular the new [[reko::reg()]] which permits specifying the register in which an argument is passed to or returned from a procedure.
  • Implemented navigation history for CodeView window.
  • Added support for ELF x86-64 and PE Thumb binaries.
  • Many bugs fixed and code refactored.

New in Reko Decompiler 0.5.1.0 (Aug 14, 2015)

  • Integrated the Capstone.NET disassembler, now used for the ARM and ARM Thumb architectures.
  • Support for Arm Thumb PE executables.
  • Bug fixes for #14 and #17.

New in Reko Decompiler 0.5.0.0 (Aug 14, 2015)

  • Moved project from SourceForge
  • Renamed project to 'Reko'
  • Started implementation of heuristic static analysis.

New in Reko Decompiler 0.4.5.0 (Jun 6, 2015)

  • Command line interpreter supports "default-to option"
  • More ARM instructions implemented
  • CP/M environment added
  • 64-bit Windows enviroment added

New in Reko Decompiler 0.4.3.0 (May 7, 2015)

  • Beginnings of new tabbed GUI
  • Command line interpreter now understands a few switches; try typing decompile --help
  • More x86 and m68k instructions supported

New in Reko Decompiler 0.4.2.0 (Apr 29, 2015)

  • Added support for PS3 and System V ELF files.
  • For fun: a C64 BASIC "decompiler"!
  • Fixed the following submitted bugs:
  • Can not load ELF or Amiga Hunk binaries
  • Can not run the decompiler from the command line
  • Implemented more x86 and PowerPC instructions
  • Improvements in SSA transformation code in preparation for move to new decompilation model
  • ImageSegmentRenders allow viewing of the structured data in image segments.

New in Reko Decompiler 0.4.1.0 (Apr 29, 2015)

  • (Crude) support for loading 32- and 64-bit PowerPC ELF binaries
  • Many PowerPC opcodes supported.
  • User interface bugfixes (broken keyboard accelerators etc)
  • The Copy command (Ctrl+C) is supported in windows where it makes sense.

New in Reko Decompiler 0.4.0.0 (Apr 29, 2015)

  • Support added for loading packed binaries using unpacker scripts written in OdbgScript.
  • Modest beginning of an X86 emulator added to the solution
  • New memory navigation bar assists in overview of binary image
  • More x86 opcodes supported.
  • Many bugs fixed.

New in Reko Decompiler 0.2.3 (May 19, 2010)

  • Fixes 2998046
  • Fixes other bugs that were uncovered by fix to 2998046.

New in Reko Decompiler 0.2.2 (May 18, 2010)

  • Much improved register parameter handling. In particular, elminated false positives on registers that were thought to emerge from procedures that can be proved to be terminating.

New in Reko Decompiler 0.2.1 (May 11, 2010)

  • Fixed 2998046
  • Fixed other bugs that were uncovered by fix to 2998046.