1 /*
2 This file is part of solidity.
3
4 solidity is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
8
9 solidity is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with solidity. If not, see <http://www.gnu.org/licenses/>.
16 */
17 // SPDX-License-Identifier: GPL-3.0
18 /**
19 * Class that contains contextual information during IR generation.
20 */
21
22 #include <libsolidity/codegen/ir/IRGenerationContext.h>
23
24 #include <libsolidity/codegen/YulUtilFunctions.h>
25 #include <libsolidity/codegen/ABIFunctions.h>
26 #include <libsolidity/codegen/CompilerUtils.h>
27 #include <libsolidity/ast/AST.h>
28 #include <libsolidity/ast/TypeProvider.h>
29
30 #include <libsolutil/Whiskers.h>
31 #include <libsolutil/StringUtils.h>
32
33 #include <range/v3/view/map.hpp>
34
35 using namespace std;
36 using namespace solidity;
37 using namespace solidity::util;
38 using namespace solidity::frontend;
39
enqueueFunctionForCodeGeneration(FunctionDefinition const & _function)40 string IRGenerationContext::enqueueFunctionForCodeGeneration(FunctionDefinition const& _function)
41 {
42 string name = IRNames::function(_function);
43
44 if (!m_functions.contains(name))
45 m_functionGenerationQueue.insert(&_function);
46
47 return name;
48 }
49
dequeueFunctionForCodeGeneration()50 FunctionDefinition const* IRGenerationContext::dequeueFunctionForCodeGeneration()
51 {
52 solAssert(!m_functionGenerationQueue.empty(), "");
53
54 FunctionDefinition const* result = *m_functionGenerationQueue.begin();
55 m_functionGenerationQueue.erase(m_functionGenerationQueue.begin());
56 return result;
57 }
58
mostDerivedContract() const59 ContractDefinition const& IRGenerationContext::mostDerivedContract() const
60 {
61 solAssert(m_mostDerivedContract, "Most derived contract requested but not set.");
62 return *m_mostDerivedContract;
63 }
64
addLocalVariable(VariableDeclaration const & _varDecl)65 IRVariable const& IRGenerationContext::addLocalVariable(VariableDeclaration const& _varDecl)
66 {
67 auto const& [it, didInsert] = m_localVariables.emplace(
68 std::make_pair(&_varDecl, IRVariable{_varDecl})
69 );
70 solAssert(didInsert, "Local variable added multiple times.");
71 return it->second;
72 }
73
localVariable(VariableDeclaration const & _varDecl)74 IRVariable const& IRGenerationContext::localVariable(VariableDeclaration const& _varDecl)
75 {
76 solAssert(
77 m_localVariables.count(&_varDecl),
78 "Unknown variable: " + _varDecl.name()
79 );
80 return m_localVariables.at(&_varDecl);
81 }
82
resetLocalVariables()83 void IRGenerationContext::resetLocalVariables()
84 {
85 m_localVariables.clear();
86 }
87
registerImmutableVariable(VariableDeclaration const & _variable)88 void IRGenerationContext::registerImmutableVariable(VariableDeclaration const& _variable)
89 {
90 solAssert(_variable.immutable(), "Attempted to register a non-immutable variable as immutable.");
91 solUnimplementedAssert(
92 _variable.annotation().type->isValueType(),
93 "Only immutable variables of value type are supported."
94 );
95 solAssert(m_reservedMemory.has_value(), "Reserved memory has already been reset.");
96 m_immutableVariables[&_variable] = CompilerUtils::generalPurposeMemoryStart + *m_reservedMemory;
97 solAssert(_variable.annotation().type->memoryHeadSize() == 32, "Memory writes might overlap.");
98 *m_reservedMemory += _variable.annotation().type->memoryHeadSize();
99 }
100
immutableMemoryOffset(VariableDeclaration const & _variable) const101 size_t IRGenerationContext::immutableMemoryOffset(VariableDeclaration const& _variable) const
102 {
103 solAssert(
104 m_immutableVariables.count(&_variable),
105 "Unknown immutable variable: " + _variable.name()
106 );
107 return m_immutableVariables.at(&_variable);
108 }
109
reservedMemory()110 size_t IRGenerationContext::reservedMemory()
111 {
112 solAssert(m_reservedMemory.has_value(), "Reserved memory was used before.");
113 size_t reservedMemory = *m_reservedMemory;
114 m_reservedMemory = std::nullopt;
115 return reservedMemory;
116 }
117
addStateVariable(VariableDeclaration const & _declaration,u256 _storageOffset,unsigned _byteOffset)118 void IRGenerationContext::addStateVariable(
119 VariableDeclaration const& _declaration,
120 u256 _storageOffset,
121 unsigned _byteOffset
122 )
123 {
124 m_stateVariables[&_declaration] = make_pair(move(_storageOffset), _byteOffset);
125 }
126
newYulVariable()127 string IRGenerationContext::newYulVariable()
128 {
129 return "_" + to_string(++m_varCounter);
130 }
131
initializeInternalDispatch(InternalDispatchMap _internalDispatch)132 void IRGenerationContext::initializeInternalDispatch(InternalDispatchMap _internalDispatch)
133 {
134 solAssert(internalDispatchClean(), "");
135
136 for (DispatchSet const& functions: _internalDispatch | ranges::views::values)
137 for (auto function: functions)
138 enqueueFunctionForCodeGeneration(*function);
139
140 m_internalDispatchMap = move(_internalDispatch);
141 }
142
consumeInternalDispatchMap()143 InternalDispatchMap IRGenerationContext::consumeInternalDispatchMap()
144 {
145 InternalDispatchMap internalDispatch = move(m_internalDispatchMap);
146 m_internalDispatchMap.clear();
147 return internalDispatch;
148 }
149
addToInternalDispatch(FunctionDefinition const & _function)150 void IRGenerationContext::addToInternalDispatch(FunctionDefinition const& _function)
151 {
152 FunctionType const* functionType = TypeProvider::function(_function, FunctionType::Kind::Internal);
153 solAssert(functionType, "");
154
155 YulArity arity = YulArity::fromType(*functionType);
156
157 if (m_internalDispatchMap.count(arity) != 0 && m_internalDispatchMap[arity].count(&_function) != 0)
158 // Note that m_internalDispatchMap[arity] is a set with a custom comparator, which looks at function IDs not definitions
159 solAssert(*m_internalDispatchMap[arity].find(&_function) == &_function, "Different definitions with the same function ID");
160
161 m_internalDispatchMap[arity].insert(&_function);
162 enqueueFunctionForCodeGeneration(_function);
163 }
164
165
internalFunctionCalledThroughDispatch(YulArity const & _arity)166 void IRGenerationContext::internalFunctionCalledThroughDispatch(YulArity const& _arity)
167 {
168 m_internalDispatchMap.try_emplace(_arity);
169 }
170
utils()171 YulUtilFunctions IRGenerationContext::utils()
172 {
173 return YulUtilFunctions(m_evmVersion, m_revertStrings, m_functions);
174 }
175
abiFunctions()176 ABIFunctions IRGenerationContext::abiFunctions()
177 {
178 return ABIFunctions(m_evmVersion, m_revertStrings, m_functions);
179 }
180
internalFunctionID(FunctionDefinition const & _function,bool _requirePresent)181 uint64_t IRGenerationContext::internalFunctionID(FunctionDefinition const& _function, bool _requirePresent)
182 {
183 auto [iterator, inserted] = m_functionIDs.try_emplace(_function.id(), m_functionIDs.size() + 1);
184 if (_requirePresent)
185 solAssert(!inserted, "");
186 return iterator->second;
187 }
188
copyFunctionIDsFrom(IRGenerationContext const & _other)189 void IRGenerationContext::copyFunctionIDsFrom(IRGenerationContext const& _other)
190 {
191 solAssert(m_functionIDs.empty(), "");
192 m_functionIDs = _other.m_functionIDs;
193 }
194