solidity/test/tools/yulopti.cpp

262 lines
7.1 KiB
C++
Raw Normal View History

2018-10-16 19:40:10 +00:00
/*
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/>.
*/
/**
* Interactive yul optimizer
*/
#include <libdevcore/CommonIO.h>
#include <liblangutil/ErrorReporter.h>
#include <liblangutil/Scanner.h>
#include <libyul/AsmAnalysis.h>
#include <libyul/AsmAnalysisInfo.h>
2018-10-16 19:40:10 +00:00
#include <libsolidity/parsing/Parser.h>
#include <libyul/AsmData.h>
#include <libyul/AsmParser.h>
#include <libyul/AsmPrinter.h>
#include <liblangutil/SourceReferenceFormatter.h>
2018-10-16 19:40:10 +00:00
#include <libyul/optimiser/BlockFlattener.h>
#include <libyul/optimiser/Disambiguator.h>
#include <libyul/optimiser/CommonSubexpressionEliminator.h>
#include <libyul/optimiser/NameCollector.h>
#include <libyul/optimiser/EquivalentFunctionCombiner.h>
2018-10-16 19:40:10 +00:00
#include <libyul/optimiser/ExpressionSplitter.h>
#include <libyul/optimiser/FunctionGrouper.h>
#include <libyul/optimiser/FunctionHoister.h>
#include <libyul/optimiser/ExpressionInliner.h>
#include <libyul/optimiser/FullInliner.h>
#include <libyul/optimiser/ForLoopInitRewriter.h>
2018-10-16 19:40:10 +00:00
#include <libyul/optimiser/MainFunction.h>
#include <libyul/optimiser/Rematerialiser.h>
#include <libyul/optimiser/ExpressionSimplifier.h>
#include <libyul/optimiser/UnusedPruner.h>
#include <libyul/optimiser/ExpressionJoiner.h>
2018-10-24 15:54:35 +00:00
#include <libyul/optimiser/RedundantAssignEliminator.h>
2019-01-16 10:44:45 +00:00
#include <libyul/optimiser/SSAReverser.h>
2018-10-24 15:54:35 +00:00
#include <libyul/optimiser/SSATransform.h>
2019-02-04 16:30:29 +00:00
#include <libyul/optimiser/StackCompressor.h>
#include <libyul/optimiser/StructuralSimplifier.h>
2018-12-13 14:53:19 +00:00
#include <libyul/optimiser/VarDeclInitializer.h>
#include <libyul/optimiser/VarNameCleaner.h>
2018-10-16 19:40:10 +00:00
2018-12-06 23:56:16 +00:00
#include <libyul/backends/evm/EVMDialect.h>
2018-10-16 19:40:10 +00:00
#include <libdevcore/JSON.h>
#include <boost/program_options.hpp>
#include <string>
#include <sstream>
#include <iostream>
using namespace std;
using namespace dev;
using namespace langutil;
2018-10-16 19:40:10 +00:00
using namespace dev::solidity;
using namespace yul;
2018-10-16 19:40:10 +00:00
namespace po = boost::program_options;
class YulOpti
{
public:
void printErrors()
2018-10-16 19:40:10 +00:00
{
SourceReferenceFormatter formatter(cout);
2018-10-16 19:40:10 +00:00
for (auto const& error: m_errors)
formatter.printExceptionInformation(
*error,
(error->type() == Error::Type::Warning) ? "Warning" : "Error"
);
}
bool parse(string const& _input)
{
ErrorReporter errorReporter(m_errors);
shared_ptr<Scanner> scanner = make_shared<Scanner>(CharStream(_input, ""));
2018-12-20 17:55:32 +00:00
m_ast = yul::Parser(errorReporter, m_dialect).parse(scanner, false);
2018-10-16 19:40:10 +00:00
if (!m_ast || !errorReporter.errors().empty())
{
cout << "Error parsing source." << endl;
printErrors();
2018-10-16 19:40:10 +00:00
return false;
}
m_analysisInfo = make_shared<yul::AsmAnalysisInfo>();
2018-10-16 19:40:10 +00:00
AsmAnalyzer analyzer(
*m_analysisInfo,
errorReporter,
langutil::Error::Type::SyntaxError,
2018-12-20 17:55:32 +00:00
m_dialect
2018-10-16 19:40:10 +00:00
);
if (!analyzer.analyze(*m_ast) || !errorReporter.errors().empty())
{
cout << "Error analyzing source." << endl;
printErrors();
2018-10-16 19:40:10 +00:00
return false;
}
return true;
}
void runInteractive(string source)
{
bool disambiguated = false;
while (true)
{
cout << "----------------------" << endl;
cout << source << endl;
if (!parse(source))
return;
if (!disambiguated)
{
2018-12-20 17:55:32 +00:00
*m_ast = boost::get<yul::Block>(Disambiguator(*m_dialect, *m_analysisInfo)(*m_ast));
2018-10-16 19:40:10 +00:00
m_analysisInfo.reset();
2018-12-20 17:55:32 +00:00
m_nameDispenser = make_shared<NameDispenser>(*m_dialect, *m_ast);
2018-10-16 19:40:10 +00:00
disambiguated = true;
}
2018-12-13 14:53:19 +00:00
cout << "(q)quit/(f)flatten/(c)se/initialize var(d)ecls/(x)plit/(j)oin/(g)rouper/(h)oister/" << endl;
cout << " (e)xpr inline/(i)nline/(s)implify/varname c(l)eaner/(u)nusedprune/ss(a) transform/" << endl;
cout << " (r)edundant assign elim./re(m)aterializer/f(o)r-loop-pre-rewriter/" << endl;
2019-02-04 16:30:29 +00:00
cout << " s(t)ructural simplifier/equi(v)alent function combiner/ssa re(V)erser/? " << endl;
cout << " stack com(p)ressor? " << endl;
2018-10-16 19:40:10 +00:00
cout.flush();
int option = readStandardInputChar();
cout << ' ' << char(option) << endl;
switch (option)
{
case 'q':
return;
case 'f':
BlockFlattener{}(*m_ast);
break;
case 'o':
ForLoopInitRewriter{}(*m_ast);
break;
2018-10-16 19:40:10 +00:00
case 'c':
2018-12-20 17:55:32 +00:00
(CommonSubexpressionEliminator{*m_dialect})(*m_ast);
2018-10-16 19:40:10 +00:00
break;
case 'd':
2018-12-13 14:53:19 +00:00
(VarDeclInitializer{})(*m_ast);
break;
case 'l':
VarNameCleaner{*m_ast, *m_dialect}(*m_ast);
break;
2018-10-16 19:40:10 +00:00
case 'x':
ExpressionSplitter{*m_dialect, *m_nameDispenser}(*m_ast);
2018-10-16 19:40:10 +00:00
break;
case 'j':
ExpressionJoiner::run(*m_ast);
break;
case 'g':
(FunctionGrouper{})(*m_ast);
break;
case 'h':
(FunctionHoister{})(*m_ast);
break;
case 'e':
2018-12-20 17:55:32 +00:00
ExpressionInliner{*m_dialect, *m_ast}.run();
2018-10-16 19:40:10 +00:00
break;
case 'i':
FullInliner(*m_ast, *m_nameDispenser).run();
break;
case 's':
2018-12-20 17:55:32 +00:00
ExpressionSimplifier::run(*m_dialect, *m_ast);
2018-10-16 19:40:10 +00:00
break;
case 't':
2018-12-20 17:55:32 +00:00
(StructuralSimplifier{*m_dialect})(*m_ast);
break;
2018-10-16 19:40:10 +00:00
case 'u':
2018-12-20 17:55:32 +00:00
UnusedPruner::runUntilStabilised(*m_dialect, *m_ast);
2018-10-16 19:40:10 +00:00
break;
2018-10-24 15:54:35 +00:00
case 'a':
SSATransform::run(*m_ast, *m_nameDispenser);
break;
case 'r':
2018-12-20 17:55:32 +00:00
RedundantAssignEliminator::run(*m_dialect, *m_ast);
2018-10-24 15:54:35 +00:00
break;
case 'm':
2018-12-20 17:55:32 +00:00
Rematerialiser::run(*m_dialect, *m_ast);
break;
case 'v':
EquivalentFunctionCombiner::run(*m_ast);
break;
2019-01-16 10:44:45 +00:00
case 'V':
2019-01-17 15:11:55 +00:00
SSAReverser::run(*m_ast);
2019-01-16 10:44:45 +00:00
break;
2019-02-04 16:30:29 +00:00
case 'p':
StackCompressor::run(m_dialect, *m_ast);
break;
2018-10-16 19:40:10 +00:00
default:
cout << "Unknown option." << endl;
}
source = AsmPrinter{}(*m_ast);
}
}
private:
ErrorList m_errors;
shared_ptr<yul::Block> m_ast;
2019-03-04 11:43:27 +00:00
shared_ptr<Dialect> m_dialect{EVMDialect::strictAssemblyForEVMObjects(EVMVersion{})};
2018-10-16 19:40:10 +00:00
shared_ptr<AsmAnalysisInfo> m_analysisInfo;
shared_ptr<NameDispenser> m_nameDispenser;
};
int main(int argc, char** argv)
{
po::options_description options(
R"(yulopti, yul optimizer exploration tool.
Usage: yulopti [Options] <file>
Reads <file> as yul code and applies optimizer steps to it,
interactively read from stdin.
Allowed options)",
po::options_description::m_default_line_length,
po::options_description::m_default_line_length - 23);
options.add_options()
(
"input-file",
po::value<string>(),
"input file"
)
("help", "Show this help screen.");
// All positional options should be interpreted as input files
po::positional_options_description filesPositions;
filesPositions.add("input-file", 1);
po::variables_map arguments;
try
{
po::command_line_parser cmdLineParser(argc, argv);
cmdLineParser.options(options).positional(filesPositions);
po::store(cmdLineParser.run(), arguments);
}
catch (po::error const& _exception)
{
cerr << _exception.what() << endl;
return 1;
}
string input;
if (arguments.count("input-file"))
YulOpti{}.runInteractive(readFileAsString(arguments["input-file"].as<string>()));
else
cout << options;
return 0;
}