Remove EOF from libevmasm

Author: rodiazet

libevmasm/Assembly.cpp

@@ -55,28 +55,18 @@ class Assembly
 	using LinkRef = std::pair<size_t, std::string>;
 
 public:
-	Assembly(langutil::EVMVersion _evmVersion, bool _creation, std::optional<uint8_t> _eofVersion, std::string _name):
+	Assembly(langutil::EVMVersion _evmVersion, bool _creation, std::string _name):
 		m_evmVersion(_evmVersion),
 		m_creation(_creation),
-		m_eofVersion(_eofVersion),
 		m_name(std::move(_name))
 	{
 		// Code section number 0 has to be non-returning.
 		m_codeSections.emplace_back(CodeSection{0, 0, true, {}});
 	}
 
-	std::optional<uint8_t> eofVersion() const { return m_eofVersion; }
-	bool supportsFunctions() const { return m_eofVersion.has_value(); }
-	bool supportsRelativeJumps() const { return m_eofVersion.has_value(); }
 	AssemblyItem newTag() { assertThrow(m_usedTags < 0xffffffff, AssemblyException, ""); return AssemblyItem(Tag, m_usedTags++); }
 	AssemblyItem newPushTag() { assertThrow(m_usedTags < 0xffffffff, AssemblyException, ""); return AssemblyItem(PushTag, m_usedTags++); }
 
-	AssemblyItem newFunctionCall(uint16_t _functionID) const;
-	AssemblyItem newFunctionReturn() const;
-	uint16_t createFunction(uint8_t _args, uint8_t _rets, bool _nonReturning);
-	void beginFunction(uint16_t _functionID);
-	void endFunction();
-
 	/// Returns a tag identified by the given name. Creates it if it does not yet exist.
 	AssemblyItem namedTag(std::string const& _name, size_t _params, size_t _returns, std::optional<uint64_t> _sourceID);
 	AssemblyItem newData(bytes const& _data) { util::h256 h(util::keccak256(util::asString(_data))); m_data[h] = _data; return AssemblyItem(PushData, h); }
@@ -89,9 +79,6 @@ class Assembly
 	AssemblyItem newPushLibraryAddress(std::string const& _identifier);
 	AssemblyItem newPushImmutable(std::string const& _identifier);
 	AssemblyItem newImmutableAssignment(std::string const& _identifier);
-	AssemblyItem newAuxDataLoadN(size_t offset) const;
-	AssemblyItem newSwapN(size_t _depth) const;
-	AssemblyItem newDupN(size_t _depth) const;
 
 	AssemblyItem const& append(AssemblyItem _i);
 	AssemblyItem const& append(bytes const& _data) { return append(newData(_data)); }
@@ -104,37 +91,12 @@ class Assembly
 	void appendLibraryAddress(std::string const& _identifier) { append(newPushLibraryAddress(_identifier)); }
 	void appendImmutable(std::string const& _identifier) { append(newPushImmutable(_identifier)); }
 	void appendImmutableAssignment(std::string const& _identifier) { append(newImmutableAssignment(_identifier)); }
-	void appendAuxDataLoadN(uint16_t _offset) { append(newAuxDataLoadN(_offset));}
-	void appendSwapN(size_t _depth) { append(newSwapN(_depth)); }
-	void appendDupN(size_t _depth) { append(newDupN(_depth)); }
 
 	void appendVerbatim(bytes _data, size_t _arguments, size_t _returnVariables)
 	{
 		append(AssemblyItem(std::move(_data), _arguments, _returnVariables));
 	}
 
-	AssemblyItem appendEOFCreate(ContainerID _containerId)
-	{
-		solAssert(_containerId < m_subs.size(), "EOF Create of undefined container.");
-		return append(AssemblyItem::eofCreate(_containerId));
-	}
-	AssemblyItem appendReturnContract(ContainerID _containerId)
-	{
-		solAssert(_containerId < m_subs.size(), "Return undefined container ID.");
-		return append(AssemblyItem::returnContract(_containerId));
-	}
-
-	AssemblyItem appendFunctionCall(uint16_t _functionID)
-	{
-		return append(newFunctionCall(_functionID));
-	}
-
-	AssemblyItem appendFunctionReturn()
-	{
-		solAssert(m_currentCodeSection != 0, "Appending function return without begin function.");
-		return append(newFunctionReturn());
-	}
-
 	AssemblyItem appendJump() { auto ret = append(newPushTag()); append(Instruction::JUMP); return ret; }
 	AssemblyItem appendJumpI() { auto ret = append(newPushTag()); append(Instruction::JUMPI); return ret; }
 	AssemblyItem appendJump(AssemblyItem const& _tag) { auto ret = append(_tag.pushTag()); append(Instruction::JUMP); return ret; }
@@ -210,8 +172,7 @@ class Assembly
 	static std::pair<std::shared_ptr<Assembly>, std::vector<std::string>> fromJSON(
 		Json const& _json,
 		std::vector<std::string> const& _sourceList = {},
-		size_t _level = 0,
-		std::optional<uint8_t> _eofVersion = std::nullopt
+		size_t _level = 0
 	);
 
 	/// Mark this assembly as invalid. Calling ``assemble`` on it will throw.
@@ -248,7 +209,7 @@ class Assembly
 	/// that are referenced in a super-assembly.
 	std::map<u256, u256> const& optimiseInternal(OptimiserSettings const& _settings, std::set<size_t> _tagsReferencedFromOutside);
 
-	/// For EOF and legacy it calculates approximate size of "pure" code without data.
+	/// Calculates approximate size of "pure" code without data.
 	unsigned codeSize(unsigned subTagSize) const;
 
 	/// Add all assembly items from given JSON array. This function imports the items by iterating through
@@ -272,16 +233,7 @@ class Assembly
 
 	std::shared_ptr<std::string const> sharedSourceName(std::string const& _name) const;
 
-	/// Returns EOF header bytecode | code section sizes offsets | data section size offset
-	std::tuple<bytes, std::vector<size_t>, size_t> createEOFHeader(std::set<ContainerID> const& _referencedSubIds) const;
-
 	LinkerObject const& assembleLegacy() const;
-	LinkerObject const& assembleEOF() const;
-
-	/// Returns map from m_subs to an index of subcontainer in the final EOF bytecode
-	std::map<ContainerID, ContainerID> findReferencedContainers() const;
-	/// Returns max AuxDataLoadN offset for the assembly.
-	std::optional<uint16_t> findMaxAuxDataLoadNOffset() const;
 
 	/// Assemble bytecode for AssemblyItem type.
 	[[nodiscard]] bytes assembleOperation(AssemblyItem const& _item) const;
@@ -333,7 +285,6 @@ class Assembly
 	int m_deposit = 0;
 	/// True, if the assembly contains contract creation code.
 	bool const m_creation = false;
-	std::optional<uint8_t> m_eofVersion;
 	/// Internal name of the assembly object, only used with the Yul backend
 	/// currently
 	std::string m_name;

libevmasm/Assembly.h

@@ -63,38 +63,20 @@ AssemblyItem AssemblyItem::toSubAssemblyTag(SubAssemblyID _subId) const
 
 std::pair<SubAssemblyID, size_t> AssemblyItem::splitForeignPushTag() const
 {
-	solAssert(m_type == PushTag || m_type == Tag || m_type == RelativeJump || m_type == ConditionalRelativeJump);
+	solAssert(m_type == PushTag || m_type == Tag);
 	u256 combined = u256(data());
 	// the combined u256 is 'dirty', so we can't use the conversion constructor of SubAssemblyID here
 	SubAssemblyID const subID{static_cast<SubAssemblyID::ValueType>((combined >> 64) - 1)};
 	size_t tag = static_cast<size_t>(combined & 0xffffffffffffffffULL);
 	return std::make_pair(subID, tag);
 }
 
-size_t AssemblyItem::relativeJumpTagID() const
-{
-	solAssert(m_type == RelativeJump || m_type == ConditionalRelativeJump);
-	auto const [subId, tagId] = splitForeignPushTag();
-	solAssert(subId.empty(), "Relative jump to sub");
-	return tagId;
-}
-
 std::pair<std::string, std::string> AssemblyItem::nameAndData(langutil::EVMVersion _evmVersion) const
 {
 	switch (type())
 	{
 	case Operation:
-	case EOFCreate:
-	case ReturnContract:
-	case RelativeJump:
-	case ConditionalRelativeJump:
-	case CallF:
-	case JumpF:
-	case RetF:
 		return {instructionInfo(instruction(), _evmVersion).name, ""};
-	case SwapN:
-	case DupN:
-		return {instructionInfo(instruction(), _evmVersion).name, util::toString(static_cast<size_t>(data())) };
 	case Push:
 		return {"PUSH", toStringInHex(data())};
 	case PushTag:
@@ -122,8 +104,6 @@ std::pair<std::string, std::string> AssemblyItem::nameAndData(langutil::EVMVersi
 		return {"PUSH data", toStringInHex(data())};
 	case VerbatimBytecode:
 		return {"VERBATIM", util::toHex(verbatimData())};
-	case AuxDataLoadN:
-		return {"AUXDATALOADN", util::toString(data())};
 	case UndefinedItem:
 		solAssert(false);
 	}
@@ -133,8 +113,7 @@ std::pair<std::string, std::string> AssemblyItem::nameAndData(langutil::EVMVersi
 
 void AssemblyItem::setPushTagSubIdAndTag(SubAssemblyID _subId, size_t _tag)
 {
-	solAssert(m_type == PushTag || m_type == Tag || m_type == RelativeJump || m_type == ConditionalRelativeJump);
-	solAssert(!(m_type == RelativeJump || m_type == ConditionalRelativeJump) || _subId.empty());
+	solAssert(m_type == PushTag || m_type == Tag);
 	u256 data = _tag;
 	if (!_subId.empty())
 		data |= (u256(_subId.value) + 1) << 64;
@@ -147,7 +126,6 @@ size_t AssemblyItem::bytesRequired(size_t _addressLength, langutil::EVMVersion _
 	{
 	case Operation:
 	case Tag: // 1 byte for the JUMPDEST
-	case RetF:
 		return 1;
 	case Push:
 		return
@@ -187,20 +165,6 @@ size_t AssemblyItem::bytesRequired(size_t _addressLength, langutil::EVMVersion _
 	}
 	case VerbatimBytecode:
 		return std::get<2>(*m_verbatimBytecode).size();
-	case RelativeJump:
-	case ConditionalRelativeJump:
-	case AuxDataLoadN:
-	case JumpF:
-	case CallF:
-		return 1 + 2;
-	case EOFCreate:
-		return 2;
-	case ReturnContract:
-		return 2;
-	case SwapN:
-		return 2;
-	case DupN:
-		return 2;
 	case UndefinedItem:
 		solAssert(false);
 	}
@@ -210,15 +174,8 @@ size_t AssemblyItem::bytesRequired(size_t _addressLength, langutil::EVMVersion _
 
 size_t AssemblyItem::arguments() const
 {
-	if (type() == CallF || type() == JumpF)
-		return functionSignature().argsNum;
-	else if (type() == SwapN)
-		return static_cast<size_t>(data()) + 1;
-	else if (type() == DupN)
-		return static_cast<size_t>(data());
-	else if (hasInstruction())
+	if (hasInstruction())
 	{
-		solAssert(instruction() != Instruction::CALLF && instruction() != Instruction::JUMPF);
 		// The latest EVMVersion is used here, since the InstructionInfo is assumed to be
 		// the same across all EVM versions except for the instruction name.
 		return static_cast<size_t>(instructionInfo(instruction(), EVMVersion()).args);
@@ -236,17 +193,9 @@ size_t AssemblyItem::returnValues() const
 	switch (m_type)
 	{
 	case Operation:
-	case EOFCreate:
-	case ReturnContract:
-	case RelativeJump:
-	case ConditionalRelativeJump:
-	case RetF:
 		// The latest EVMVersion is used here, since the InstructionInfo is assumed to be
 		// the same across all EVM versions except for the instruction name.
 		return static_cast<size_t>(instructionInfo(instruction(), EVMVersion()).ret);
-	case SwapN:
-	case DupN:
-		return static_cast<size_t>(data()) + 1;
 	case Push:
 	case PushTag:
 	case PushData:
@@ -261,11 +210,6 @@ size_t AssemblyItem::returnValues() const
 		return 0;
 	case VerbatimBytecode:
 		return std::get<1>(*m_verbatimBytecode);
-	case AuxDataLoadN:
-		return 1;
-	case JumpF:
-	case CallF:
-		return functionSignature().retsNum;
 	case AssignImmutable:
 	case UndefinedItem:
 		break;
@@ -280,16 +224,6 @@ bool AssemblyItem::canBeFunctional() const
 	switch (m_type)
 	{
 	case Operation:
-	case EOFCreate:
-	case ReturnContract:
-	case RelativeJump:
-	case ConditionalRelativeJump:
-	case CallF:
-	case JumpF:
-	case SwapN:
-	case DupN:
-	case RetF:
-		return !SemanticInformation::isDupInstruction(*this) && !SemanticInformation::isSwapInstruction(*this);
 	case Push:
 	case PushTag:
 	case PushData:
@@ -299,7 +233,6 @@ bool AssemblyItem::canBeFunctional() const
 	case PushLibraryAddress:
 	case PushDeployTimeAddress:
 	case PushImmutable:
-	case AuxDataLoadN:
 		return true;
 	case Tag:
 		return false;
@@ -401,37 +334,6 @@ std::string AssemblyItem::toAssemblyText(Assembly const& _assembly) const
 	case VerbatimBytecode:
 		text = std::string("verbatimbytecode_") + util::toHex(std::get<2>(*m_verbatimBytecode));
 		break;
-	case AuxDataLoadN:
-		assertThrow(data() <= std::numeric_limits<size_t>::max(), AssemblyException, "Invalid auxdataloadn argument.");
-		text = "auxdataloadn{" +  std::to_string(static_cast<size_t>(data())) + "}";
-		break;
-	case EOFCreate:
-		text = "eofcreate{" +  std::to_string(static_cast<size_t>(data())) + "}";
-		break;
-	case ReturnContract:
-		text = "returncontract{" +  std::to_string(static_cast<size_t>(data())) + "}";
-		break;
-	case RelativeJump:
-		text = "rjump{" + std::string("tag_") + std::to_string(relativeJumpTagID()) + "}";
-		break;
-	case ConditionalRelativeJump:
-		text = "rjumpi{" + std::string("tag_") + std::to_string(relativeJumpTagID()) + "}";
-		break;
-	case CallF:
-		text = "callf{" + std::string("code_section_") +  std::to_string(static_cast<size_t>(data())) + "}";
-		break;
-	case JumpF:
-		text = "jumpf{" + std::string("code_section_") +  std::to_string(static_cast<size_t>(data())) + "}";
-		break;
-	case RetF:
-		text = "retf";
-		break;
-	case SwapN:
-		text = "swapn{" + std::to_string(static_cast<size_t>(data())) + "}";
-		break;
-	case DupN:
-		text = "dupn{" + std::to_string(static_cast<size_t>(data())) + "}";
-		break;
 	}
 	if (m_jumpType == JumpType::IntoFunction || m_jumpType == JumpType::OutOfFunction)
 	{
@@ -450,15 +352,6 @@ std::ostream& solidity::evmasm::operator<<(std::ostream& _out, AssemblyItem cons
 	switch (_item.type())
 	{
 	case Operation:
-	case EOFCreate:
-	case ReturnContract:
-	case RelativeJump:
-	case ConditionalRelativeJump:
-	case CallF:
-	case JumpF:
-	case RetF:
-	case SwapN:
-	case DupN:
 		_out << " " << instructionInfo(_item.instruction(), EVMVersion()).name;
 		if (_item.instruction() == Instruction::JUMP || _item.instruction() == Instruction::JUMPI)
 			_out << "\t" << _item.getJumpTypeAsString();
@@ -508,9 +401,6 @@ std::ostream& solidity::evmasm::operator<<(std::ostream& _out, AssemblyItem cons
 	case VerbatimBytecode:
 		_out << " Verbatim " << util::toHex(_item.verbatimData());
 		break;
-	case AuxDataLoadN:
-		_out << " AuxDataLoadN " << util::toString(_item.data());
-		break;
 	case UndefinedItem:
 		_out << " ???";
 		break;
@@ -563,9 +453,9 @@ std::string AssemblyItem::computeSourceMapping(
 			static_cast<int>(_sourceIndicesMap.at(*location.sourceName)) :
 			-1;
 		char jump = '-';
-		if (item.getJumpType() == evmasm::AssemblyItem::JumpType::IntoFunction || item.type() == CallF || item.type() == JumpF)
+		if (item.getJumpType() == evmasm::AssemblyItem::JumpType::IntoFunction)
 			jump = 'i';
-		else if (item.getJumpType() == evmasm::AssemblyItem::JumpType::OutOfFunction || item.type() == RetF)
+		else if (item.getJumpType() == evmasm::AssemblyItem::JumpType::OutOfFunction)
 			jump = 'o';
 		int modifierDepth = static_cast<int>(item.m_modifierDepth);