Reko Versions Save

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.

Thanks to @chostelet, @claunia, @ermshiperete, @gbody, @Piruzzolo, @ptomin, and @smx-smx for their time and contributions to this release.

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 worst: that 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.

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.

Thanks to @gbody, @wdigger, @wesinator, @wildptr for their contributions. Special thanks to @chostelet, @ptomin and @smx-smx for their code, time, and dedication.

Release notes:

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.

Thanks to @dmakarov, @Lukas-Dresel, @Kalmalyzer, @VladRassokhin, @gbody, @chostelet for their contributions. Special thanks to @ptomin and @smx-smx for their code, time, and devotion.

Another bug release and courtesy build to users unable to build their own binaries.

• 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

Thanks to @ptomin , @smx-smx , and @rogersachan for their contributions.

This is mostly a bugfix release and a courtesy builds to users unable to build their own binaries.

• 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

Thanks to @ptomin and @smx-smx for their contributions, and @rfalke for reporting issues found in testing.

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:

    decompile --heuristic shingle binary.exe

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

Thanks to @ptomin, @Kalmalyzer, and @smx-smx for their contributions.

Mostly consisting of bugfixes and stability improvements.

• Function previewer in the mixed-asm-data window:
• Added support for Wii and RT-11 platforms
• Added support for RT-11 LDA and SAV files, and Nintendo DOL files.
• Add support for custom loader. Users can provide their own front-ends to Reko.
• Support for parsing GCC symbols
• Added support for Atmel AVR8, Risc-V, and Xtensa AVR8 processor architectures
• Added [[reko::arg(fpu)]] C++-style attribute
• #213: more work on the jump table dialog

Thanks to @ptomin, @a2intl, @Lukas-Dresel, @MeFisto94, @rogersachan, and @smx-smx for their contributions

This minor release focuses on stabilization, but a few major features have made it as well:

• 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

Special thanks to @ptomin, @nemerle, @mewmew, @xor2003, @Lukas-Dresel for their contibutions.

At last, a new major release! Большое спасибо to @ptomin, who put in an amazing amount of effort to bring you:

• Combined code and low-level viewer, to allow users to compare Reko's output with the original binary.
• Improvements in user-specified data types

In the eye candy department:

• A graph viewer, to help users to visualize procedure call graph (thanks to @halsten for the suggestion)
• 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

And the nuts and bolts work:

• New reko configuration and project file formats
• 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"

Because of the major changes that have taken place, it's likely that Reko may be unstable after all the major surgery. If you encounter any issues while running Reko, please report them in the issue tracker.

Enjoy!