/* 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 . */ // SPDX-License-Identifier: GPL-3.0 /** * Full assembly stack that can support EVM-assembly and Yul as input and EVM, EVM1.5 and * Ewasm as output. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; using namespace solidity; using namespace solidity::yul; using namespace solidity::langutil; namespace { Dialect const& languageToDialect(AssemblyStack::Language _language, EVMVersion _version) { switch (_language) { case AssemblyStack::Language::Assembly: case AssemblyStack::Language::StrictAssembly: return EVMDialect::strictAssemblyForEVMObjects(_version); case AssemblyStack::Language::Yul: return EVMDialectTyped::instance(_version); case AssemblyStack::Language::Ewasm: return WasmDialect::instance(); } yulAssert(false, ""); return Dialect::yulDeprecated(); } } Scanner const& AssemblyStack::scanner() const { yulAssert(m_scanner, ""); return *m_scanner; } bool AssemblyStack::parseAndAnalyze(std::string const& _sourceName, std::string const& _source) { m_errors.clear(); m_analysisSuccessful = false; m_scanner = make_shared(CharStream(_source, _sourceName)); m_parserResult = ObjectParser(m_errorReporter, languageToDialect(m_language, m_evmVersion)).parse(m_scanner, false); if (!m_errorReporter.errors().empty()) return false; yulAssert(m_parserResult, ""); yulAssert(m_parserResult->code, ""); return analyzeParsed(); } void AssemblyStack::optimize() { if (!m_optimiserSettings.runYulOptimiser) return; yulAssert(m_analysisSuccessful, "Analysis was not successful."); m_analysisSuccessful = false; yulAssert(m_parserResult, ""); optimize(*m_parserResult, true); yulAssert(analyzeParsed(), "Invalid source code after optimization."); } void AssemblyStack::translate(AssemblyStack::Language _targetLanguage) { if (m_language == _targetLanguage) return; yulAssert( m_language == Language::StrictAssembly && _targetLanguage == Language::Ewasm, "Invalid language combination" ); *m_parserResult = EVMToEwasmTranslator( languageToDialect(m_language, m_evmVersion) ).run(*parserResult()); m_language = _targetLanguage; } bool AssemblyStack::analyzeParsed() { yulAssert(m_parserResult, ""); m_analysisSuccessful = analyzeParsed(*m_parserResult); return m_analysisSuccessful; } bool AssemblyStack::analyzeParsed(Object& _object) { yulAssert(_object.code, ""); _object.analysisInfo = make_shared(); AsmAnalyzer analyzer( *_object.analysisInfo, m_errorReporter, languageToDialect(m_language, m_evmVersion), {}, _object.dataNames() ); bool success = analyzer.analyze(*_object.code); for (auto& subNode: _object.subObjects) if (auto subObject = dynamic_cast(subNode.get())) if (!analyzeParsed(*subObject)) success = false; return success; } void AssemblyStack::compileEVM(AbstractAssembly& _assembly, bool _evm15, bool _optimize) const { EVMDialect const* dialect = nullptr; switch (m_language) { case Language::Assembly: case Language::StrictAssembly: dialect = &EVMDialect::strictAssemblyForEVMObjects(m_evmVersion); break; case Language::Yul: dialect = &EVMDialectTyped::instance(m_evmVersion); break; default: yulAssert(false, "Invalid language."); break; } EVMObjectCompiler::compile(*m_parserResult, _assembly, *dialect, _evm15, _optimize); } void AssemblyStack::optimize(Object& _object, bool _isCreation) { yulAssert(_object.code, ""); yulAssert(_object.analysisInfo, ""); for (auto& subNode: _object.subObjects) if (auto subObject = dynamic_cast(subNode.get())) optimize(*subObject, false); Dialect const& dialect = languageToDialect(m_language, m_evmVersion); unique_ptr meter; if (EVMDialect const* evmDialect = dynamic_cast(&dialect)) meter = make_unique(*evmDialect, _isCreation, m_optimiserSettings.expectedExecutionsPerDeployment); OptimiserSuite::run( dialect, meter.get(), _object, m_optimiserSettings.optimizeStackAllocation, m_optimiserSettings.yulOptimiserSteps ); } MachineAssemblyObject AssemblyStack::assemble(Machine _machine) const { yulAssert(m_analysisSuccessful, ""); yulAssert(m_parserResult, ""); yulAssert(m_parserResult->code, ""); yulAssert(m_parserResult->analysisInfo, ""); switch (_machine) { case Machine::EVM: return assembleAndGuessRuntime().first; case Machine::EVM15: { MachineAssemblyObject object; EVMAssembly assembly(true); compileEVM(assembly, true, m_optimiserSettings.optimizeStackAllocation); object.bytecode = make_shared(assembly.finalize()); /// TODO: fill out text representation return object; } case Machine::Ewasm: { yulAssert(m_language == Language::Ewasm, ""); Dialect const& dialect = languageToDialect(m_language, EVMVersion{}); MachineAssemblyObject object; auto result = WasmObjectCompiler::compile(*m_parserResult, dialect); object.assembly = std::move(result.first); object.bytecode = make_shared(); object.bytecode->bytecode = std::move(result.second); return object; } } // unreachable return MachineAssemblyObject(); } pair AssemblyStack::assembleAndGuessRuntime() const { yulAssert(m_analysisSuccessful, ""); yulAssert(m_parserResult, ""); yulAssert(m_parserResult->code, ""); yulAssert(m_parserResult->analysisInfo, ""); evmasm::Assembly assembly; EthAssemblyAdapter adapter(assembly); compileEVM(adapter, false, m_optimiserSettings.optimizeStackAllocation); MachineAssemblyObject creationObject; creationObject.bytecode = make_shared(assembly.assemble()); yulAssert(creationObject.bytecode->immutableReferences.empty(), "Leftover immutables."); creationObject.assembly = assembly.assemblyString(); creationObject.sourceMappings = make_unique( evmasm::AssemblyItem::computeSourceMapping( assembly.items(), {{scanner().charStream() ? scanner().charStream()->name() : "", 0}} ) ); MachineAssemblyObject runtimeObject; // Heuristic: If there is a single sub-assembly, this is likely the runtime object. if (assembly.numSubs() == 1) { evmasm::Assembly& runtimeAssembly = assembly.sub(0); runtimeObject.bytecode = make_shared(runtimeAssembly.assemble()); runtimeObject.assembly = runtimeAssembly.assemblyString(); runtimeObject.sourceMappings = make_unique( evmasm::AssemblyItem::computeSourceMapping( runtimeAssembly.items(), {{scanner().charStream() ? scanner().charStream()->name() : "", 0}} ) ); } return {std::move(creationObject), std::move(runtimeObject)}; } string AssemblyStack::print() const { yulAssert(m_parserResult, ""); yulAssert(m_parserResult->code, ""); return m_parserResult->toString(&languageToDialect(m_language, m_evmVersion)) + "\n"; } shared_ptr AssemblyStack::parserResult() const { yulAssert(m_analysisSuccessful, "Analysis was not successful."); yulAssert(m_parserResult, ""); yulAssert(m_parserResult->code, ""); return m_parserResult; }