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/>.
|
|
|
|
*/
|
2020-07-17 14:54:12 +00:00
|
|
|
// SPDX-License-Identifier: GPL-3.0
|
2019-03-04 22:26:46 +00:00
|
|
|
/**
|
|
|
|
* Class that contains contextual information during IR generation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
2020-04-09 19:59:17 +00:00
|
|
|
#include <libsolidity/ast/AST.h>
|
2020-02-06 13:05:25 +00:00
|
|
|
#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>
|
2020-05-13 17:48:31 +00:00
|
|
|
#include <libsolidity/codegen/ir/Common.h>
|
2019-03-04 22:26:46 +00:00
|
|
|
|
|
|
|
#include <liblangutil/EVMVersion.h>
|
|
|
|
|
2020-01-06 10:52:23 +00:00
|
|
|
#include <libsolutil/Common.h>
|
2019-04-30 16:32:56 +00:00
|
|
|
|
2020-04-10 17:16:44 +00:00
|
|
|
#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
|
|
|
{
|
|
|
|
|
2019-04-30 16:32:56 +00:00
|
|
|
class YulUtilFunctions;
|
2020-04-09 19:59:17 +00:00
|
|
|
class ABIFunctions;
|
2019-03-04 22:26:46 +00:00
|
|
|
|
2020-12-01 15:52:57 +00:00
|
|
|
struct AscendingFunctionIDCompare
|
|
|
|
{
|
|
|
|
bool operator()(FunctionDefinition const* _f1, FunctionDefinition const* _f2) const
|
|
|
|
{
|
|
|
|
// NULLs always first.
|
|
|
|
if (_f1 != nullptr && _f2 != nullptr)
|
|
|
|
return _f1->id() < _f2->id();
|
|
|
|
else
|
|
|
|
return _f1 == nullptr;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
using DispatchSet = std::set<FunctionDefinition const*, AscendingFunctionIDCompare>;
|
|
|
|
using InternalDispatchMap = std::map<YulArity, DispatchSet>;
|
2020-05-19 19:50:22 +00:00
|
|
|
|
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),
|
2020-03-02 17:08:19 +00:00
|
|
|
m_optimiserSettings(std::move(_optimiserSettings))
|
2019-03-04 22:26:46 +00:00
|
|
|
{}
|
|
|
|
|
2020-03-02 17:08:19 +00:00
|
|
|
MultiUseYulFunctionCollector& functionCollector() { return m_functions; }
|
2019-03-04 22:26:46 +00:00
|
|
|
|
2020-04-10 17:16:44 +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(); }
|
|
|
|
|
2020-03-24 17:25:59 +00:00
|
|
|
/// Sets the most derived contract (the one currently being compiled)>
|
|
|
|
void setMostDerivedContract(ContractDefinition const& _mostDerivedContract)
|
2019-04-02 10:37:48 +00:00
|
|
|
{
|
2020-03-24 17:25:59 +00:00
|
|
|
m_mostDerivedContract = &_mostDerivedContract;
|
2019-04-02 10:37:48 +00:00
|
|
|
}
|
2020-03-24 17:25:59 +00:00
|
|
|
ContractDefinition const& mostDerivedContract() const;
|
2019-04-02 10:37:48 +00:00
|
|
|
|
|
|
|
|
2020-02-06 13:05:25 +00:00
|
|
|
IRVariable const& addLocalVariable(VariableDeclaration const& _varDecl);
|
2019-04-30 16:32:56 +00:00
|
|
|
bool isLocalVariable(VariableDeclaration const& _varDecl) const { return m_localVariables.count(&_varDecl); }
|
2020-02-06 13:05:25 +00:00
|
|
|
IRVariable const& localVariable(VariableDeclaration const& _varDecl);
|
2019-04-30 16:32:56 +00:00
|
|
|
|
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();
|
|
|
|
|
2019-04-30 16:32:56 +00:00
|
|
|
void addStateVariable(VariableDeclaration const& _varDecl, u256 _storageOffset, unsigned _byteOffset);
|
|
|
|
bool isStateVariable(VariableDeclaration const& _varDecl) const { return m_stateVariables.count(&_varDecl); }
|
2020-08-21 12:27:00 +00:00
|
|
|
std::pair<u256, unsigned> storageLocationOfStateVariable(VariableDeclaration const& _varDecl) const
|
2019-04-30 16:32:56 +00:00
|
|
|
{
|
2020-08-21 12:27:00 +00:00
|
|
|
solAssert(isStateVariable(_varDecl), "");
|
2019-04-30 16:32:56 +00:00
|
|
|
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-05-19 19:50:22 +00:00
|
|
|
void initializeInternalDispatch(InternalDispatchMap _internalDispatchMap);
|
|
|
|
InternalDispatchMap consumeInternalDispatchMap();
|
2020-11-24 12:13:18 +00:00
|
|
|
bool internalDispatchClean() const { return m_internalDispatchMap.empty(); }
|
2020-05-19 19:50:22 +00:00
|
|
|
|
|
|
|
/// Notifies the context that a function call that needs to go through internal dispatch was
|
|
|
|
/// encountered while visiting the AST. This ensures that the corresponding dispatch function
|
|
|
|
/// gets added to the dispatch map even if there are no entries in it (which may happen if
|
|
|
|
/// the code contains a call to an uninitialized function variable).
|
|
|
|
void internalFunctionCalledThroughDispatch(YulArity const& _arity);
|
|
|
|
|
2020-11-24 12:13:18 +00:00
|
|
|
/// Adds a function to the internal dispatch.
|
|
|
|
void addToInternalDispatch(FunctionDefinition const& _function);
|
2019-04-02 10:37:48 +00:00
|
|
|
|
2019-04-30 16:32:56 +00:00
|
|
|
/// @returns a new copy of the utility function generator (but using the same function set).
|
|
|
|
YulUtilFunctions utils();
|
|
|
|
|
2020-11-11 21:55:38 +00:00
|
|
|
langutil::EVMVersion evmVersion() const { return m_evmVersion; }
|
2019-04-30 17:08:02 +00:00
|
|
|
|
2020-04-09 19:59:17 +00:00
|
|
|
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; }
|
|
|
|
|
2020-04-09 19:59:17 +00:00
|
|
|
std::set<ContractDefinition const*, ASTNode::CompareByID>& subObjectsCreated() { return m_subObjects; }
|
|
|
|
|
2020-07-02 10:48:20 +00:00
|
|
|
bool inlineAssemblySeen() const { return m_inlineAssemblySeen; }
|
|
|
|
void setInlineAssemblySeen() { m_inlineAssemblySeen = true; }
|
|
|
|
|
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;
|
2020-03-24 17:25:59 +00:00
|
|
|
ContractDefinition const* m_mostDerivedContract = nullptr;
|
2020-02-06 13:05:25 +00:00
|
|
|
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};
|
2019-04-30 16:32:56 +00:00
|
|
|
/// Storage offsets of state variables
|
|
|
|
std::map<VariableDeclaration const*, std::pair<u256, unsigned>> m_stateVariables;
|
2020-03-02 17:08:19 +00:00
|
|
|
MultiUseYulFunctionCollector m_functions;
|
2019-03-18 10:21:41 +00:00
|
|
|
size_t m_varCounter = 0;
|
2020-04-10 17:16:44 +00:00
|
|
|
|
2020-07-02 10:48:20 +00:00
|
|
|
/// Flag indicating whether any inline assembly block was seen.
|
|
|
|
bool m_inlineAssemblySeen = false;
|
|
|
|
|
2020-04-10 17:16:44 +00:00
|
|
|
/// 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.
|
2020-12-01 15:52:57 +00:00
|
|
|
DispatchSet m_functionGenerationQueue;
|
2020-04-09 19:59:17 +00:00
|
|
|
|
2020-05-19 19:50:22 +00:00
|
|
|
/// Collection of functions that need to be callable via internal dispatch.
|
|
|
|
/// Note that having a key with an empty set of functions is a valid situation. It means that
|
|
|
|
/// the code contains a call via a pointer even though a specific function is never assigned to it.
|
|
|
|
/// It will fail at runtime but the code must still compile.
|
|
|
|
InternalDispatchMap m_internalDispatchMap;
|
|
|
|
|
2020-04-09 19:59:17 +00:00
|
|
|
std::set<ContractDefinition const*, ASTNode::CompareByID> m_subObjects;
|
2019-03-04 22:26:46 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
}
|