Yul: Introduces ASTNodeRegistry

libyul/ASTNodeRegistry.cpp

@@ -0,0 +1,172 @@
+/*
+	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/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#include <libyul/ASTNodeRegistry.h>
+
+#include <libyul/Exceptions.h>
+
+#include <fmt/format.h>
+
+#include <range/v3/algorithm/max.hpp>
+#include <range/v3/view/map.hpp>
+
+using namespace solidity::yul;
+
+ASTNodeRegistry::ASTNodeRegistry(): m_labels{""}, m_idToLabelMapping{0} {}
+
+ASTNodeRegistry::ASTNodeRegistry(std::vector<std::string> _labels, std::vector<size_t> _idToLabelMapping)
+{
+	yulAssert(_labels.size() >= 1);
+	yulAssert(_labels[0].empty());
+	yulAssert(_idToLabelMapping.size() >= 1);
+	yulAssert(_idToLabelMapping[0] == 0);
+	// using vector<uint8_t> over vector<bool>, as the latter is optimized for space-efficiency
+	std::vector<uint8_t> labelVisited (_labels.size(), false);
+	size_t numLabels = 0;
+	for (auto const& id: _idToLabelMapping)
+	{
+		if (id == ghostId())
+			continue;
+		yulAssert(id < _labels.size());
+		// it is possible to have multiple references to empty / ghost
+		yulAssert(
+			id == 0 || !labelVisited[id],
+			fmt::format("NodeId {} (label \"{}\") is not unique.", id, _labels[id])
+		);
+		labelVisited[id] = true;
+		if (id >= 1)
+			++numLabels;
+	}
+	yulAssert(numLabels + 1 == _labels.size(), "Unused labels present.");
+	m_labels = std::move(_labels);
+	m_idToLabelMapping = std::move(_idToLabelMapping);
+}
+
+ASTNodeRegistry::NodeId ASTNodeRegistry::maximumId() const
+{
+	yulAssert(m_idToLabelMapping.size() > 0);
+	return m_idToLabelMapping.size() - 1;
+}
+
+size_t ASTNodeRegistry::idToLabelIndex(NodeId const _id) const
+{
+	yulAssert(_id < m_idToLabelMapping.size());
+	return m_idToLabelMapping[_id];
+}
+
+std::string_view ASTNodeRegistry::operator[](NodeId const _id) const
+{
+	auto const labelIndex = idToLabelIndex(_id);
+	if (labelIndex == ghostId())
+		return lookupGhost(_id);
+	return m_labels[labelIndex];
+}
+
+std::optional<ASTNodeRegistry::NodeId> ASTNodeRegistry::findIdForLabel(std::string_view const _label) const {
+	if (_label.empty())
+		return emptyId();
+	for (NodeId id = 1; id <= maximumId(); ++id)
+		if ((*this)[id] == _label)
+			return id;
+	return std::nullopt;
+}
+
+std::string_view ASTNodeRegistry::lookupGhost(NodeId const _id) const
+{
+	yulAssert(idToLabelIndex(_id) == ghostId());
+	auto const [it, _] = m_ghostLabelCache.try_emplace(_id, fmt::format("GHOST[{}]", _id));
+	return it->second;
+}
+
+ASTNodeRegistryBuilder::DefinedLabels::DefinedLabels():
+	m_mapping{{"", 0}}
+{}
+
+std::tuple<ASTNodeRegistry::NodeId, bool> ASTNodeRegistryBuilder::DefinedLabels::tryInsert(
+	std::string_view const _label,
+	ASTNodeRegistry::NodeId const _id
+)
+{
+	auto const [it, emplaced] = m_mapping.try_emplace(std::string{_label}, _id);
+	return std::make_tuple(it->second, emplaced);
+}
+
+ASTNodeRegistryBuilder::ASTNodeRegistryBuilder():
+	m_nextId(1)
+{}
+
+ASTNodeRegistryBuilder::ASTNodeRegistryBuilder(ASTNodeRegistry const& _existingRegistry)
+{
+	auto const maxId = _existingRegistry.maximumId();
+	yulAssert(_existingRegistry[0] == "");
+	for (size_t i = 1; i <= maxId; ++i)
+	{
+		auto const existingLabel = _existingRegistry[i];
+		if (!existingLabel.empty())
+		{
+			if (_existingRegistry.idToLabelIndex(i) == ASTNodeRegistry::ghostId())
+				m_ghosts.push_back(i);
+			else
+			{
+				auto const [_, inserted] = m_definedLabels.tryInsert(_existingRegistry[i], i);
+				yulAssert(inserted);
+			}
+		}
+	}
+	m_nextId = _existingRegistry.maximumId() + 1;
+}
+
+ASTNodeRegistry::NodeId ASTNodeRegistryBuilder::define(std::string_view const _label)
+{
+	auto const [id, inserted] = m_definedLabels.tryInsert(_label, m_nextId);
+	if (inserted)
+		m_nextId++;
+	return id;
+}
+
+ASTNodeRegistry::NodeId ASTNodeRegistryBuilder::addGhost()
+{
+	m_ghosts.push_back(m_nextId);
+	return m_nextId++;
+}
+
+ASTNodeRegistry ASTNodeRegistryBuilder::build() const
+{
+	auto const& labelToIdMapping = m_definedLabels.labelToIdMapping();
+	yulAssert(labelToIdMapping.contains(""));
+	yulAssert(labelToIdMapping.at("") == 0);
+
+	std::vector<std::string> labels{""};
+	labels.reserve(labelToIdMapping.size());
+	auto const maxLabelId = ranges::max(labelToIdMapping | ranges::views::values);
+	auto const maxGhostId = m_ghosts.empty() ? 0 : m_ghosts.back();
+	std::vector<size_t> idToLabelMapping( std::max(maxLabelId, maxGhostId) + 1, 0);
+	yulAssert(idToLabelMapping.size() >= 1, "Mapping must at least contain empty label");
+	for (auto const& [label, id]: labelToIdMapping)
+	{
+		// skip empty and ghost
+		if (id < 1)
+			continue;
+
+		labels.emplace_back(label);
+		idToLabelMapping[id] = labels.size() - 1;
+	}
+	for (auto const ghostId: m_ghosts)
+		idToLabelMapping[ghostId] = ASTNodeRegistry::ghostId();
+	return ASTNodeRegistry{std::move(labels), std::move(idToLabelMapping)};
+}

libyul/ASTNodeRegistry.h

@@ -0,0 +1,95 @@
+/*
+	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/>.
+*/
+// SPDX-License-Identifier: GPL-3.0
+
+#pragma once
+
+#include <limits>
+#include <map>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace solidity::yul
+{
+
+/// Instances of the `ASTNodeRegistry` are immutable containers describing a labelling of nodes inside the AST.
+/// Each element of the AST that possesses a label has a `ASTNodeRegistry::NodeId`, with which the label can
+/// be queried in O(1).
+/// Preferred way of creating instances is via `ASTNodeRegistryBuilder` when parsing/importing and
+/// via `NodeIdDispenser` during/after optimization.
+class ASTNodeRegistry
+{
+public:
+	/// unsafe to use from a different registry instance, it is up to the user to safeguard against this
+	using NodeId = size_t;
+
+	ASTNodeRegistry();
+	ASTNodeRegistry(std::vector<std::string> _labels, std::vector<size_t> _idToLabelMapping);
+
+	std::string_view operator[](NodeId _id) const;
+
+	static bool constexpr empty(NodeId const _id) { return _id == emptyId(); }
+	static NodeId constexpr emptyId() { return 0; }
+	static NodeId constexpr ghostId() { return std::numeric_limits<NodeId>::max(); }
+
+	std::vector<std::string> const& labels() const { return m_labels; }
+	NodeId maximumId() const;
+
+	size_t idToLabelIndex(NodeId _id) const;
+	/// this is a potentially expensive operation
+	std::optional<NodeId> findIdForLabel(std::string_view _label) const;
+private:
+	std::string_view lookupGhost(NodeId _id) const;
+
+	/// unique labels in the container, beginning with empty ("") and ghost (ghostPlaceholder).
+	std::vector<std::string> m_labels;
+	/// Each element in the vector is one NodeId. The value of the vector points to the corresponding label. E.g.,
+	/// m_labels[m_idToLabelMapping[3]] is the label for NodeId 3. Therefore, there can be duplicates and the lengths
+	/// of `m_labels` and `m_idToLabelMapping` do not need to correspond.
+	std::vector<size_t> m_idToLabelMapping;
+	mutable std::map<NodeId, std::string> m_ghostLabelCache;
+};
+
+/// Produces instances of `ASTNodeRegistry`. Preferably used during parsing/importing.
+class ASTNodeRegistryBuilder
+{
+public:
+	ASTNodeRegistryBuilder();
+	explicit ASTNodeRegistryBuilder(ASTNodeRegistry const& _existingRegistry);
+	ASTNodeRegistry::NodeId define(std::string_view _label);
+	ASTNodeRegistry::NodeId addGhost();
+	ASTNodeRegistry build() const;
+private:
+	class DefinedLabels
+	{
+	public:
+		DefinedLabels();
+		std::tuple<ASTNodeRegistry::NodeId, bool> tryInsert(std::string_view _label, ASTNodeRegistry::NodeId _id);
+
+		auto const& labelToIdMapping() const { return m_mapping; }
+	private:
+		std::map<std::string, size_t, std::less<>> m_mapping;
+	};
+
+	DefinedLabels m_definedLabels;
+	std::vector<ASTNodeRegistry::NodeId> m_ghosts;
+	size_t m_nextId = 0;
+};
+
+}

libyul/CMakeLists.txt

@@ -7,6 +7,8 @@ add_library(yul
 	AST.h
 	AST.cpp
 	ASTForward.h
+	ASTNodeRegistry.cpp
+	ASTNodeRegistry.h
 	AsmJsonConverter.h
 	AsmJsonConverter.cpp
 	AsmJsonImporter.h