[WIP] Struct encoder

[chriseth]

• reduce duplication of generated code
• simple JULIA optimizer stage
• check where ABI encoders from storage are used, verify code coverage and add tests if needed

Currently, we can only reduce duplication if all encoders are handled in a single pass of the JULIA parser, because only then we can have different JULIA functions referencing themselves. This is only possible if the ABI encoder has a label we can jump to. This requires the following refactorings:

Each call to encodeToMemory has to be changed to an actual function call and for that, the return label has to be put onto the stack before the values to encode are put onto the stack.

Furthermore, we have to have a way to reference a label in a piece of JULIA code from outside of that JULIA code and this also has to be possible before that code is even parsed.

I think the best solution to this problem is to provide a string as a hint to AbstractAssembly::newLabelID so that the EVM assembly can specially prepare some label ids to be linked properly.

Depends on #1673 and #2704.

[axic]

The function uses lowercase _to_. Actually this isn't even used, wouldn't a list suffice?

[axic]

Please rebase to use Whiskers 😉

[chriseth]

Only fails 105 out of 422 end to end test! :-)

[chriseth]

Down to 69

[axic]

Can we merge this optimisation right now?

[chriseth]

The optimizer (if not the peephole optimizer) will fix that, but yes, I can try to extract it.

[axic]

Perhaps take this with the other change too (in general I like those specific solUnimplementedAsserts better from a user's perspective).

[chriseth]

No, this has to be an assert in current develop, I changed it to an unimplemented because of the new struct types.

[axic]

Please rebase.

[chriseth]

Down to 61 errors in SolidityEndToEndTests.

[chriseth]

By the way, an example encoder now looks as follows:

{
        let dynFree := add($headStart, 64)
        dynFree := abi_encode_t_bytes2_to_t_bytes3($value0, $headStart, add($headStart, 0), dynFree)
        dynFree := abi_encode_t_bool_to_t_bool($value1, $headStart, add($headStart, 32), dynFree)
        $value0 := dynFree
        function abi_encode_t_bool_to_t_bool(value, headStart, headPos, dyn) -> newDyn
        {
            newDyn := dyn
            mstore(headPos, cleanup_assert_t_bool(value))
        }
        function abi_encode_t_bytes2_to_t_bytes3(value, headStart, headPos, dyn) -> newDyn
        {
            newDyn := dyn
            mstore(headPos, convert_t_bytes2_to_t_bytes3(value))
        }
        function cleanup_assert_t_bool(value) -> cleaned
        {
            cleaned := iszero(iszero(value))
        }
        function cleanup_assert_t_bytes2(value) -> cleaned
        {
            cleaned := and(value, 0xFFFF000000000000000000000000000000000000000000000000000000000000)
        }
        function convert_t_bytes2_to_t_bytes3(value) -> converted
        {
            converted := cleanup_assert_t_bytes2(value)
        }
    }

I.e. it has very detailed "convert" and "cleanup" calls which makes it very visible what happens and those can also probably be easily inlined.

[chriseth]

59!

[chriseth]

24!

[chriseth]

14!

[chriseth]

Only one failing test left, but this is due to the fact that we do not use codecopy for constants, but I think this will also turn green once we have deduplication.

Still, more test coverage is needed.

[chriseth]

Oh and it turns out, the storage-to-ABI-encoder is actually used, but it seems there are only few tests for it.

[axic]

Where is this modified?

[axic]

Can you pull the tests which should succeed on the current encoder into a separate PR and merge them first?