Hex-Rays v1.3 vs. v1.2 Decompiler Comparison Page
Below you will find side-by-side comparisons of v1.2 and v1.3 decompilations. Please maximize the window too see both columns simultaneously.
The following examples are displayed on this page:
- Better 64-bit arithmetics
- Better 64-bit arithmetics - 2
- 64-bit comparisons
- Nested pointer, array, and structure references
- Assignments and comma operators
- Global propagation of calculated values
- Calculated values - 2
- Improved register argument detection
- Simpler arithmeric operations
- References to arrays of structures
- Improved optimizer
- Improved optimizer - 2
- Fast structural analysis
- Floating point constants
- More precise variable creation
- Postincrement/decrement with comparisons
- Constant strings
- Shorter output
NOTE: these are just some selected examples that can be illustrated as a side-by-side difference. Hex-Rays Decompiler v1.3 includes are many other improvements and new features that are not mentioned on this page - simply because there was nothing to compare them with. Also, some improvements have already been illustrated in the previous comparisons. Please refer to the news page for more details.
Better 64-bit arithmetics
It seems that 64-bit support is a never ending story. The previous version of the decompiler could not recognize the 64-bit addition because it was interleaved with other operations and the value of an operand changed midway. The new version can handle it, and the output is much simpler.
Better 64-bit arithmetics - 2
An unrecognized 64-bit addition may lead to other complications.
On the left, we have
v10 32-bit variables, on the right there is
one simple 64-bit
v10 variable. Note the difference.
We added more rules to recognize 64-bit comparisons. The results are pleasing.
Nested pointer, array, and structure references
Complex references like pointers to arrays to pointers to (the list may go on) were
not always recognized and represented nicely. Only one level of indirection was handled nicely, deeper references might look ugly.
Now the decompiler does a much better job.
(the type of
char (**a3g), so the expression on the left is correct too)
Assignments and comma operators
Nobody likes comma operators but the decompiler has to revert to them to get rid of
In some cases they can still be eliminated and that's what the new version does.
Global propagation of calculated values
Note that the decompiler replaced the
result variable with its known value, zero.
Knowing a variable value enables many other optimizations and can simplify the output
very much. It also removes false dependencies: for example, the previous version had
to introduce a cast to
Calculated values - 2
Since we know that value of
v1 in the
if-branch, we can replace it with zero,
which leads to simplifications. The output is much cleaner.
Improved register argument detection
The heurstics to detect register arguments has been improved. The output does not require any comments.
Simpler arithmeric operations
References to arrays of structures
First, references to arrays of structures are much better. Second, the decompiler could determine that v20 is used only to access the array and divided it by the array element size (12).
It is difficult to say what exactly improvement of the decompiler led to this result, but we like it anyway. The decompiler could get rid of intermediate variables and simplify the code to the maximum.
Improved optimizer - 2
Yet another example of improved output. There are many other improved things, like inlined
strlen and other functions, we are just getting too many examples anyway...
Fast structural analysis
We tweaked the structural analysis: now it is faster (especially on big functions) and produces more concise output.
Note that there is only one
if operator now. Since not everyone likes dense
code, this is configurable.
Floating point constants
Floating point constants are detected even if they are moved around using integer
manipulation commands (a simple
More precise variable creation
The decompiler determined that even if
v6 variables are initialized as 32-bit entities, only 16-bits are used.
It declared them as 16-bit variables. This leads to better output.
Postincrement/decrement with comparisons
Postincrement/decrement operators with comparisons were leading to ugly output, now it is simpler and ready to be simplified even more.
References into the middle of constact strings were not recognized, forcing the user to jump to the string to learn its value. Now the life is simpler.
It seems that the fast structural analysis combined with the improved loop recognition made it possible to shorten the output. Whatever the reason is, we like the output on the right.