Alignment considerations all over the place where growing increasingly
verbose and complex, increasing the likelihood of getting them wrong.
This unifies all the alignment logic in one place.
There were issues with how trailing padding is processed which sometimes
led to it being discarded. That should not happen from now on.
As a size benefit this also strictens the exit condition and improves
wording on some of the comments.
Some ABI's (think mips) require a part of the stack to be reserved,
but before this patch we treated those fields as arguments.
Note that this analysis never inserts fields, so if there are no
sufficient field already inserted before-hand it's just going to fail
the conversion (for example, if the field at the *newly adjusted*
offset 0 is not present).
Add the `revng::cantFail` function which allows to wrap functions with
`std::error_code` and check their result. This is analogous to
`llvm::cantFail` for `llvm::Error`.
Before this commit, char literals were always printed with html
escaping, even if the associated PTML builder was set to Tagless.
This commit fixes the problem.
Before this commit, the DLAStep DeduplicateFields was using
NotMergedNode (a reference) in an assertion, in a place where it was
already invalidated by a preceding call to
CollapseSingleChild::collapseSingle that can mutate the graph.
This caused the assertion to trigger erroneously in some situations.
This commit moves the assertion earlier, in a place where the reference
is guaranteed to always be valid.
Passes without an artifact and a single successor are pointless anyway.
You can't get their output with revng artifact but you need to save
them on disk.
At the moment this pipe is broken, because it claims to be producing
artifacts with function rank, while it only produces types.
This pipe should be extended and turned into a pipe that generates
the whole Clift module including functions from LLVM IR, and not just
types.
We should add an input LLVMContainer, and the run() method should first
import types, and then create the functions and their bodies.
For the time being the Pipe is removed from the pipeline.
The previous conversion from LLVM to MLIR was translating plain LLVM IR
to LLVM MLIR Dialect, as a preliminary step for further conversion from
LLVM MLIR Dialect to Clift.
This is not how things are expected to work anymore, so the old code is
now dead and can be removed.
Introduce LegacySegregateStackAccessesPipe
This commit restructures the SegregateStackAccesses pass and
SegregateStackAccessesPipe so that they can have 2 modes of operations:
1. Legacy, with the same behavior as the old version, injecting local
variables as custom llvm::Functions representing opcodes, such as
LocalVariable, AddressOf, StackFrameAllocator, and CallStackArguments
allocator.
2. Non-legacy, that is meant to operate with the new LocalVariableHelper
to inject local variables as regular alloca instructions, with
additional metadata to discriminate among them.
This commit renames the old SegregateStackAccessesPipe to
LegacySegregateStackAccessesPipe.
It then re-uses the old SegregateStackAccessesPipe name for a new pipe,
meant to work in non-legacy mode.
The pipeline definition YAML file is updated to keep using the legacy
version for now.
For now the implementation is still the same.
This commit changes the prototype of getCopeType, so that it now takes 2
arguments.
1. The llvm::Type returned by the Copy function. This can be any scalar
llvm::Type.
2. The llvm::type of the argument representing the reference to the
value being copied. This should be a pointer-sized integer, where
pointer-sized means with the same size of a pointer in the
architecture in the input binary.
The second argument is not strictly necessary for now, because the whole
decompilation framework expects a binary with a single architecture,
hence a well defined unambiguous pointer size.
This will be used fully only when we start supporting multiple binaries.
Whenever that happens, if we haven't already fully dropped the Copy
helper function we will have to update the associated
OpaqueFunctionsPool to a type pair as key: the return type and the type
of the argument.
Before this commit `StoreInst` weren't supported because they weren't
expected to reach the late stages of the decompilation pipeline where
the `hasSideEffects` helper function is used.
They were expected to be replaced by custom opcodes marked with
`FunctionTags::Assign`.
With the upcoming switch to the new decompilation pipeline, this helper
needs to be able to handle `StoreInst`s, because the custom opcode
functions will be dropped in favor of regular LLVM memory accesses.
This is preliminary to unifying the creation and handling of local
variable declarations, to simplify switching over to local variables
represented by plain allocas.
Ivan Krysak