Skip to content

Commit 5bc5d98

Browse files
clonkerclonker
committed
Yul: Introduces ASTNodeRegistry
1 parent cfd32a3 commit 5bc5d98

File tree

3 files changed

+301
-0
lines changed

3 files changed

+301
-0
lines changed

‎libyul/ASTLabelRegistry.cpp

+194
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,194 @@
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+
#include <libyul/ASTLabelRegistry.h>
20+
21+
#include <libyul/Exceptions.h>
22+
23+
#include <fmt/format.h>
24+
25+
#include <range/v3/algorithm/all_of.hpp>
26+
#include <range/v3/algorithm/max.hpp>
27+
#include <range/v3/view/map.hpp>
28+
29+
using namespace solidity::yul;
30+
31+
namespace
32+
{
33+
34+
bool isInGhostFormat(std::string_view const _label)
35+
{
36+
using namespace std::literals::string_view_literals;
37+
static size_t constexpr prefixLength = "GHOST["sv.length();
38+
static size_t constexpr postfixLength = "]"sv.length();
39+
if (_label.size() < prefixLength + postfixLength + 1)
40+
return false;
41+
if (!_label.starts_with("GHOST[") || !_label.ends_with("]"))
42+
return false;
43+
44+
auto const maybeID = _label.substr(prefixLength, _label.size() - prefixLength - postfixLength);
45+
return ranges::all_of(maybeID, isdigit);
46+
}
47+
48+
}
49+
50+
ASTLabelRegistry::ASTLabelRegistry(): m_labels{""}, m_idToLabelMapping{0} {}
51+
52+
ASTLabelRegistry::ASTLabelRegistry(std::vector<std::string> _labels, std::vector<size_t> _idToLabelMapping)
53+
{
54+
yulAssert(!_labels.empty());
55+
yulAssert(_labels[0].empty());
56+
yulAssert(!_idToLabelMapping.empty());
57+
yulAssert(_idToLabelMapping[0] == 0);
58+
// using vector<uint8_t> over vector<bool>, as the latter is optimized for space-efficiency
59+
std::vector<uint8_t> labelVisited (_labels.size(), false);
60+
size_t numLabels = 0;
61+
for (auto const& labelIndex: _idToLabelMapping)
62+
{
63+
if (labelIndex == ghostId())
64+
continue;
65+
yulAssert(labelIndex < _labels.size());
66+
// it is possible to have multiple references to empty / ghost
67+
yulAssert(
68+
labelIndex == 0 || !labelVisited[labelIndex],
69+
fmt::format("LabelID {} (label \"{}\") is not unique.", labelIndex, _labels[labelIndex])
70+
);
71+
labelVisited[labelIndex] = true;
72+
yulAssert(!isInGhostFormat(_labels[labelIndex]), "Labels of the form GHOST[id] are reserved.");
73+
if (labelIndex >= 1)
74+
++numLabels;
75+
}
76+
yulAssert(numLabels + 1 == _labels.size(), "Unused labels present.");
77+
m_labels = std::move(_labels);
78+
m_idToLabelMapping = std::move(_idToLabelMapping);
79+
}
80+
81+
ASTLabelRegistry::LabelID ASTLabelRegistry::maximumId() const
82+
{
83+
yulAssert(!m_idToLabelMapping.empty());
84+
return m_idToLabelMapping.size() - 1;
85+
}
86+
87+
size_t ASTLabelRegistry::idToLabelIndex(LabelID const _id) const
88+
{
89+
yulAssert(_id < m_idToLabelMapping.size());
90+
return m_idToLabelMapping[_id];
91+
}
92+
93+
std::string_view ASTLabelRegistry::operator[](LabelID const _id) const
94+
{
95+
auto const labelIndex = idToLabelIndex(_id);
96+
if (labelIndex == ghostId())
97+
return lookupGhost(_id);
98+
return m_labels[labelIndex];
99+
}
100+
101+
std::optional<ASTLabelRegistry::LabelID> ASTLabelRegistry::findIdForLabel(std::string_view const _label) const {
102+
if (_label.empty())
103+
return emptyId();
104+
for (LabelID id = 1; id <= maximumId(); ++id)
105+
if ((*this)[id] == _label)
106+
return id;
107+
return std::nullopt;
108+
}
109+
110+
std::string_view ASTLabelRegistry::lookupGhost(LabelID const _id) const
111+
{
112+
yulAssert(idToLabelIndex(_id) == ghostId());
113+
auto const [it, _] = m_ghostLabelCache.try_emplace(_id, fmt::format("GHOST[{}]", _id));
114+
return it->second;
115+
}
116+
117+
ASTLabelRegistryBuilder::DefinedLabels::DefinedLabels():
118+
m_mapping{{"", 0}}
119+
{}
120+
121+
std::tuple<ASTLabelRegistry::LabelID, bool> ASTLabelRegistryBuilder::DefinedLabels::tryInsert(
122+
std::string_view const _label,
123+
ASTLabelRegistry::LabelID const _id
124+
)
125+
{
126+
auto const [it, emplaced] = m_mapping.try_emplace(std::string{_label}, _id);
127+
return std::make_tuple(it->second, emplaced);
128+
}
129+
130+
ASTLabelRegistryBuilder::ASTLabelRegistryBuilder():
131+
m_nextId(1)
132+
{}
133+
134+
ASTLabelRegistryBuilder::ASTLabelRegistryBuilder(ASTLabelRegistry const& _existingRegistry)
135+
{
136+
yulAssert(!_existingRegistry.labels().empty() && _existingRegistry[0].empty());
137+
auto const maxId = _existingRegistry.maximumId();
138+
for (size_t i = 1; i <= maxId; ++i)
139+
{
140+
auto const existingLabel = _existingRegistry[i];
141+
if (!existingLabel.empty())
142+
{
143+
if (_existingRegistry.idToLabelIndex(i) == ASTLabelRegistry::ghostId())
144+
m_ghosts.push_back(i);
145+
else
146+
{
147+
auto const [_, inserted] = m_definedLabels.tryInsert(_existingRegistry[i], i);
148+
yulAssert(inserted);
149+
}
150+
}
151+
}
152+
m_nextId = _existingRegistry.maximumId() + 1;
153+
}
154+
155+
ASTLabelRegistry::LabelID ASTLabelRegistryBuilder::define(std::string_view const _label)
156+
{
157+
yulAssert(!isInGhostFormat(_label));
158+
auto const [id, inserted] = m_definedLabels.tryInsert(_label, m_nextId);
159+
if (inserted)
160+
m_nextId++;
161+
return id;
162+
}
163+
164+
ASTLabelRegistry::LabelID ASTLabelRegistryBuilder::addGhost()
165+
{
166+
m_ghosts.push_back(m_nextId);
167+
return m_nextId++;
168+
}
169+
170+
ASTLabelRegistry ASTLabelRegistryBuilder::build() const
171+
{
172+
auto const& labelToIdMapping = m_definedLabels.labelToIdMapping();
173+
yulAssert(labelToIdMapping.contains(""));
174+
yulAssert(labelToIdMapping.at("") == 0);
175+
176+
std::vector<std::string> labels{""};
177+
labels.reserve(labelToIdMapping.size());
178+
auto const maxLabelId = ranges::max(labelToIdMapping | ranges::views::values);
179+
auto const maxGhostId = m_ghosts.empty() ? 0 : m_ghosts.back();
180+
std::vector<size_t> idToLabelMapping( std::max(maxLabelId, maxGhostId) + 1, 0);
181+
yulAssert(!idToLabelMapping.empty(), "Mapping must at least contain empty label");
182+
for (auto const& [label, id]: labelToIdMapping)
183+
{
184+
// skip empty and ghost
185+
if (id < 1)
186+
continue;
187+
188+
labels.emplace_back(label);
189+
idToLabelMapping[id] = labels.size() - 1;
190+
}
191+
for (auto const ghostId: m_ghosts)
192+
idToLabelMapping[ghostId] = ASTLabelRegistry::ghostId();
193+
return ASTLabelRegistry{std::move(labels), std::move(idToLabelMapping)};
194+
}

‎libyul/ASTLabelRegistry.h

+105
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,105 @@
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+
#pragma once
20+
21+
#include <limits>
22+
#include <map>
23+
#include <optional>
24+
#include <string>
25+
#include <string_view>
26+
#include <vector>
27+
28+
namespace solidity::yul
29+
{
30+
31+
/// Instances of the `ASTLabelRegistry` are immutable containers describing a labelling of nodes inside the AST.
32+
/// Each element of the AST that possesses a label has a `ASTLabelRegistry::LabelID`, with which the label can
33+
/// be queried in O(1).
34+
/// Preferred way of creating instances is via `ASTLabelRegistryBuilder` when parsing/importing and
35+
/// via `LabelIDDispenser` during/after optimization.
36+
/// Note: There is a special case of ghost ids, which are added during CFG construction.
37+
/// They do not directly correspond to elements of an AST but live inside the CFG. They are assigned the
38+
/// special `std::numeric_limits<LabelID>::max` label index and are labelled as `GHOST[{id}]`,
39+
/// corresponding to their label `id`.
40+
class ASTLabelRegistry
41+
{
42+
public:
43+
/// unsafe to use from a different registry instance, it is up to the user to safeguard against this
44+
using LabelID = size_t;
45+
46+
ASTLabelRegistry();
47+
ASTLabelRegistry(std::vector<std::string> _labels, std::vector<size_t> _idToLabelMapping);
48+
49+
std::string_view operator[](LabelID _id) const;
50+
51+
static bool constexpr empty(LabelID const _id) { return _id == emptyId(); }
52+
static LabelID constexpr emptyId() { return 0; }
53+
static LabelID constexpr ghostId() { return std::numeric_limits<LabelID>::max(); }
54+
55+
std::vector<std::string> const& labels() const { return m_labels; }
56+
LabelID maximumId() const;
57+
58+
size_t idToLabelIndex(LabelID _id) const;
59+
/// this is a potentially expensive operation
60+
std::optional<LabelID> findIdForLabel(std::string_view _label) const;
61+
private:
62+
std::string_view lookupGhost(LabelID _id) const;
63+
64+
/// All Yul AST labels present in the registry.
65+
/// Always contains at least an empty label which also serves as a null-state for non-contiguous ID ranges.
66+
/// All items must be unique.
67+
std::vector<std::string> m_labels;
68+
69+
/// Assignment of labels to `LabelID`s. Indices are `LabelID`s and values are indices into `m_labels`.
70+
/// Every label except empty and ghost placeholder always has exactly one `LabelID` pointing at it.
71+
std::vector<size_t> m_idToLabelMapping;
72+
73+
/// Artificial labels generated for ghost IDs from a template.
74+
/// Generated on demand through `lookupGhost()` and cached for future lookups.
75+
/// Must never contain non-ghost IDs. Labels are guaranteed to be unique.
76+
mutable std::map<LabelID, std::string> m_ghostLabelCache;
77+
};
78+
79+
/// Produces instances of `ASTLabelRegistry`. Preferably used during parsing/importing.
80+
class ASTLabelRegistryBuilder
81+
{
82+
public:
83+
ASTLabelRegistryBuilder();
84+
explicit ASTLabelRegistryBuilder(ASTLabelRegistry const& _existingRegistry);
85+
ASTLabelRegistry::LabelID define(std::string_view _label);
86+
ASTLabelRegistry::LabelID addGhost();
87+
ASTLabelRegistry build() const;
88+
private:
89+
class DefinedLabels
90+
{
91+
public:
92+
DefinedLabels();
93+
std::tuple<ASTLabelRegistry::LabelID, bool> tryInsert(std::string_view _label, ASTLabelRegistry::LabelID _id);
94+
95+
auto const& labelToIdMapping() const { return m_mapping; }
96+
private:
97+
std::map<std::string, size_t, std::less<>> m_mapping;
98+
};
99+
100+
DefinedLabels m_definedLabels;
101+
std::vector<ASTLabelRegistry::LabelID> m_ghosts;
102+
size_t m_nextId = 0;
103+
};
104+
105+
}

‎libyul/CMakeLists.txt

+2
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,8 @@ add_library(yul
77
AST.h
88
AST.cpp
99
ASTForward.h
10+
ASTLabelRegistry.cpp
11+
ASTLabelRegistry.h
1012
AsmJsonConverter.h
1113
AsmJsonConverter.cpp
1214
AsmJsonImporter.h

0 commit comments

Comments
 (0)