Variable declarations are no longer displayed in the debug view "Variables".

Improved displaying of type modifiers in the Variables view.

Added action to return to the node in the analysis graph that has been used
to query interactive value analysis results.

Creating and cloning analyses is now also possible via a context menu in the Analyses
list on the left of the ał window (see screenshot).

ERC32/LEON2/LEON3: more freely configurable memory timing.

AIS

Beginning to introduce the AIS2 language extension.

New annotation to allow specifying the content of memory cells within
“is entered with” annotations. Only usable in the AIS2 extension. Example:

ais2 { instruction 0x111 enter with: mem (reg("sp") - 8, 4) = 0; }

New annotation “exit with”, analogous to “enter with”
but evaluated at the exit of given program point (instruction or routine). Example:

ais2 { instruction 0x111 exit with: mem (reg("sp") - 8, 4) = 1; }

New ValueAnalyzer directive to output the values of certain global variables at branches:

routine <routine> trace <variables list>;

The user may now annotate computed call targets per routine. For example:

routine "main" calls "A", "B", "C";

routine "main" calls via "array" [12];

Decoding

Improved loop transformation. Multi-entry loops are now transformed into loop routines
in most cases (see screenshot).
This enables annotating them with the “loop + 1 loop max xx;”
annotation rather than using flow constraints. As the "flow each" constraint needs
all blocks to be in the same routine, some annotations might need to be adjusted.
An error will be issued if this is necessary. If a loop is not reducible to a loop routine,
the members of the irreducible loop will be reported to the user together with possible inner nested irreducible loops.

Improved recursion output.
Any kind of recursion (if reducible or not) will be shown to the user together with all members and nested recursions.

Improved decoding performance, avoiding reiteration of decoding in most cases.

Less memory usage during decoding of binaries.

The decoder now provides annotation hints on how to resolve computed call targets
via NULL pointer indirection. For example:

Automatically derived call targets are no longer discarded if the value analysis detects that multiple call targets are possible.
Instead, the corresponding call instruction is marked as having more call targets (i.e., the list of call targets is only partially resolved).
To resolve this issue the user has to provide an AIS annotation.

Stack and value analysis

Changes to calling conventions for stack and value analysis. The automatic classification of routines
as satisfying or violating calling conventions has changed:

Dummy calls and calls which return immediately are always classified to be
violating the calling conventions. This classification cannot be changed by the
user.

Other routines that don't assign unknown values to the stack pointer and which
are terminated by an explicit return instruction are automatically classified as
satisfying the calling conventions. This classification can be overwritten by the
user to "violates calling conventions".

The user is responsible to mark decoded routines that do not preserve the values
of callee saved registers as violating the calling conventions if they are not
automatically classified as such routines (i.e. if they are not dummy calls
or returning immediately).

Stack analysis:

Assignments to the stack pointer now lead to an unknown stack level (previously to stack level 0).
An exception are assignments to the stack pointer for the purpose of restoring a saved stack pointer
value near the end of a routine, provided that the saved value is known.

Improved handling of stack modifying loops.
If StackAnalyzer is able to detect that the loop really itself has a stack effect,
it will auto-unroll it and try to detect a loop bound.
Otherwise, it will inform the user, if the stack analysis fails because of possible
stack loops and allows to unroll them via the special annotation "modifies stack". Example annotation:

ais2 { loop "test.L1" modifies stack; }

Allow to switch to a faster stackanalysis mode that doesn't have the information
about all possible worst-case stack paths. "Number of worst case stack usage paths to compute"
cannot be used if this "Faster stack analysis without worst-case path information at routines" is enabled.

More precise stack analysis if function calls are infeasible.

Other general changes:

Loops that are never left are no longer marked as infeasible but can end program execution after each iteration.
This allows more flexible handling of such loops, like using "additional starts" to analyze the functions called inside such loops.

The value analysis may invalidate computed register contents or computed call targets during iterative decoding if it detects that other values are possible.

Warnings about misaligned memory accesses are postponed from the loop analysis to the value analysis step to avoid unnecessary messages.

Path analysis

Semantic changes to busy waiting loop annotation "loop "test" + 1 loop takes max 1000 cycles":
Timing specifications for loops are implemented by pretending that the loop is not executed at all, and assigning the specified time to the loop call node of the loop in its host routine.
This avoids ILP complexity and makes busy waiting loop annotations faster to solve.

Visualization and reporting

For each unresolved computed call, ał now introduces a virtual call target named
:UnresolvedTarget_A where A is the address of the call.
The virtual call target disappears when the computed call is resolved by annotations
that inform ał about the call targets.

If the unresolved computed call is not resolved by providing its targets,
but by declaring that its targets should not be analyzed, then the virtual call
target :UnresolvedTarget_A is renamed into :NotAnalyzedTarget_A.

The user can now choose between three different levels for the visualization of infeasible routines:
hide all infeasible routines, show top-level infeasible routines, show all infeasible routines.
(See screenshot).