* An object that represents a sequence of optimiser steps that can be applied to a program. * Such sequences are used in our genetic algorithm to rep

* Moustache-like templates. * * Usage: * std::vector<std::map<std::string, std::string>> listValues(2); * listValues[0]["k"] = "key1"; *

* An IRVariable refers to a set of yul variables that correspond to the stack layout of a Solidity variable or expression * of a specific Solidity ty

C++ representation of an SMTLIB2 expression.

* An expression, i.e. something that has a value (which can also be of type "void" in case * of some function calls). * @abstract */

AnsiColorized provides a convenience helper to colorize ostream with formatting-reset assured.

The big-endian 160-bit hash suitable for keeping an Ethereum address. This type wraps C ::evmc_address to make sure objects of this type are always i

* Information describing the state of an individual member of the population during the course * of the genetic algorithm. */

* Class that provides code generation for handling arrays. */

* A selection that selects a contiguous slice of the container. Start and end of this part are * specified as percentages of its size. */

Conditional execution without "else" part.

* A selection that selects elements at specific, fixed positions indicated by a repeating "pattern". * If the positions in the pattern exceed the siz

* A selection that selects pairs of random elements from a container. The resulting set of pairs * may contain the same pair more than once but does

* A selection that selects pairs of elements at specific, fixed positions indicated by a repeating * "pattern". If the positions in the pattern excee

* A version specifier of the EVM we want to compile to. * Defaults to the latest version deployed on Ethereum Mainnet at the time of compiler release

* A selection that randomly selects elements from a container. The resulting set of indices may * contain duplicates and is different on each call to

* A selection that goes over all elements in a container, for each one independently decides * whether to select it or not and then randomly combines

forward

Returns true if protobuf array specification is well-formed, false otherwise

* The type of a contract instance or library, there is one distinct type for each contract definition. */

* Any kind of integer type (signed, unsigned). */

* Fitness metric based on the size of a specific program after applying the optimisations from the * chromosome to it in relation to the original, un

* The type of an array. The flavours are byte array (bytes), statically- (<type>[<length>]) * and dynamically-sized array (<type>[]). * In storage,

* Bytes type with fixed length of up to 32 bytes. */

* A selection that goes over all elements in a container, for each one independently deciding * whether to select it or not. Each element has the sam

* Converter of the AST into JSON format */

* Identifier for a block, coincides with the tag number of an AssemblyItem but adds a special * ID for the initial block. */

Virtual machine bytecode instruction.

Returns a valid value (as a string) for a given type.

* Class to generate encoding and decoding functions. Also maintains a collection * of "functions to be generated" in order to avoid generating the sa

* Creates a copy of a Yul AST replacing all identifiers by unique names. */

* Compiler for expressions, i.e. converts an AST tree whose root is an Expression into a stream * of EVM instructions. It needs a compiler context th

If Block `_from` -> Block `_to` and `_to` has phi functions `v_k := phi(..., _from => v_i, ...)`, this transform pulls values `v_k` back to `v_i`.

* Integer and fixed point constants either literals or computed. * Example expressions: 2, 3.14, 2+10.2, ~10. * There is one distinct type per value

* Specific AST walker that determines side-effect free-ness and movability of code. * Enters into function definitions. */

* Creates a copy of a Yul AST potentially replacing identifier names. * Base class to be extended. */

* Performs the full analysis stage, calls the ScopeFiller internally, then resolves * references and performs other checks. * If all these checks pa

* Converter of the yul AST into JSON format */

* Helper base class for implementing handlers. */

* Special type for magic variables (block, msg, tx, type(...)), similar to a struct but without any reference. * * It is also the type shared by all

* Class that represents a function, public state variable or modifier * and helps with overload checking. * Regular comparison is performed based on

Sub assembly ID representing class. Based on fixed-size 64-bit unsigned int. An empty / root state is reflected by a value that is set to max and can

* The purpose of the ABI type is the storage of type information * retrieved while parsing a test. This information is used * for the conversion of

* Converts a parsed Yul AST into readable string representation. * Ignores source locations. */

* The boolean type. */

* Component that checks whether all variables are reachable on the stack and * provides a mapping from function name to the largest stack difference

Returns true if visited type is dynamically encoded by the abi coder, false otherwise.

* Reference to an immutable variable. During contract creation this refers to a location in memory. At the * end of contract creation the values from

Information structure for a particular instruction.

* Reference to some item in memory. */

* Fitness metric based on the size of a specific program after applying the optimisations from the * chromosome to it. */