solidity/libsolidity/codegen/ir/IRGenerationContext.h

152 lines
5.6 KiB
C
Raw Normal View History

2019-03-04 22:26:46 +00:00
/*
This file is part of solidity.
solidity is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
solidity is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with solidity. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* Class that contains contextual information during IR generation.
*/
#pragma once
#include <libsolidity/ast/AST.h>
#include <libsolidity/codegen/ir/IRVariable.h>
2019-03-04 22:26:46 +00:00
#include <libsolidity/interface/OptimiserSettings.h>
2020-01-22 14:48:56 +00:00
#include <libsolidity/interface/DebugSettings.h>
2019-03-04 22:26:46 +00:00
#include <libsolidity/codegen/MultiUseYulFunctionCollector.h>
#include <libsolidity/codegen/ir/Common.h>
2019-03-04 22:26:46 +00:00
#include <liblangutil/EVMVersion.h>
#include <libsolutil/Common.h>
#include <set>
2019-03-04 22:26:46 +00:00
#include <string>
#include <memory>
2019-04-02 10:37:48 +00:00
#include <vector>
2019-03-04 22:26:46 +00:00
2019-12-11 16:31:36 +00:00
namespace solidity::frontend
2019-03-04 22:26:46 +00:00
{
class YulUtilFunctions;
class ABIFunctions;
2019-03-04 22:26:46 +00:00
/**
* Class that contains contextual information during IR generation.
*/
class IRGenerationContext
{
public:
2020-01-22 14:48:56 +00:00
IRGenerationContext(
langutil::EVMVersion _evmVersion,
RevertStrings _revertStrings,
OptimiserSettings _optimiserSettings
):
2019-03-04 22:26:46 +00:00
m_evmVersion(_evmVersion),
2020-01-22 14:48:56 +00:00
m_revertStrings(_revertStrings),
m_optimiserSettings(std::move(_optimiserSettings))
2019-03-04 22:26:46 +00:00
{}
MultiUseYulFunctionCollector& functionCollector() { return m_functions; }
2019-03-04 22:26:46 +00:00
/// Adds a Solidity function to the function generation queue and returns the name of the
/// corresponding Yul function.
std::string enqueueFunctionForCodeGeneration(FunctionDefinition const& _function);
/// Pops one item from the function generation queue. Must not be called if the queue is empty.
FunctionDefinition const* dequeueFunctionForCodeGeneration();
bool functionGenerationQueueEmpty() { return m_functionGenerationQueue.empty(); }
/// Sets the most derived contract (the one currently being compiled)>
void setMostDerivedContract(ContractDefinition const& _mostDerivedContract)
2019-04-02 10:37:48 +00:00
{
m_mostDerivedContract = &_mostDerivedContract;
2019-04-02 10:37:48 +00:00
}
ContractDefinition const& mostDerivedContract() const;
2019-04-02 10:37:48 +00:00
IRVariable const& addLocalVariable(VariableDeclaration const& _varDecl);
bool isLocalVariable(VariableDeclaration const& _varDecl) const { return m_localVariables.count(&_varDecl); }
IRVariable const& localVariable(VariableDeclaration const& _varDecl);
2020-04-02 18:06:52 +00:00
/// Registers an immutable variable of the contract.
/// Should only be called at construction time.
void registerImmutableVariable(VariableDeclaration const& _varDecl);
/// @returns the reserved memory for storing the value of the
/// immutable @a _variable during contract creation.
size_t immutableMemoryOffset(VariableDeclaration const& _variable) const;
/// @returns the reserved memory and resets it to mark it as used.
/// Intended to be used only once for initializing the free memory pointer
/// to after the area used for immutables.
size_t reservedMemory();
void addStateVariable(VariableDeclaration const& _varDecl, u256 _storageOffset, unsigned _byteOffset);
bool isStateVariable(VariableDeclaration const& _varDecl) const { return m_stateVariables.count(&_varDecl); }
std::pair<u256, unsigned> storageLocationOfVariable(VariableDeclaration const& _varDecl) const
{
return m_stateVariables.at(&_varDecl);
}
2019-03-18 10:21:41 +00:00
std::string newYulVariable();
2019-03-04 22:26:46 +00:00
2020-04-28 11:15:26 +00:00
std::string internalDispatch(YulArity const& _arity);
2019-04-02 10:37:48 +00:00
/// @returns a new copy of the utility function generator (but using the same function set).
YulUtilFunctions utils();
langutil::EVMVersion evmVersion() const { return m_evmVersion; };
ABIFunctions abiFunctions();
2020-01-22 14:48:56 +00:00
/// @returns code that stores @param _message for revert reason
/// if m_revertStrings is debug.
std::string revertReasonIfDebug(std::string const& _message = "");
RevertStrings revertStrings() const { return m_revertStrings; }
std::set<ContractDefinition const*, ASTNode::CompareByID>& subObjectsCreated() { return m_subObjects; }
2019-03-04 22:26:46 +00:00
private:
langutil::EVMVersion m_evmVersion;
2020-01-22 14:48:56 +00:00
RevertStrings m_revertStrings;
2019-03-04 22:26:46 +00:00
OptimiserSettings m_optimiserSettings;
ContractDefinition const* m_mostDerivedContract = nullptr;
std::map<VariableDeclaration const*, IRVariable> m_localVariables;
2020-04-02 18:06:52 +00:00
/// Memory offsets reserved for the values of immutable variables during contract creation.
/// This map is empty in the runtime context.
std::map<VariableDeclaration const*, size_t> m_immutableVariables;
/// Total amount of reserved memory. Reserved memory is used to store
/// immutable variables during contract creation.
std::optional<size_t> m_reservedMemory = {0};
/// Storage offsets of state variables
std::map<VariableDeclaration const*, std::pair<u256, unsigned>> m_stateVariables;
MultiUseYulFunctionCollector m_functions;
2019-03-18 10:21:41 +00:00
size_t m_varCounter = 0;
/// Function definitions queued for code generation. They're the Solidity functions whose calls
/// were discovered by the IR generator during AST traversal.
/// Note that the queue gets filled in a lazy way - new definitions can be added while the
/// collected ones get removed and traversed.
/// The order and duplicates are irrelevant here (hence std::set rather than std::queue) as
/// long as the order of Yul functions in the generated code is deterministic and the same on
/// all platforms - which is a property guaranteed by MultiUseYulFunctionCollector.
std::set<FunctionDefinition const*> m_functionGenerationQueue;
std::set<ContractDefinition const*, ASTNode::CompareByID> m_subObjects;
2019-03-04 22:26:46 +00:00
};
}