solidity/libsolidity/inlineasm/AsmAnalysis.cpp

402 lines
11 KiB
C++
Raw Normal View History

2017-02-15 13:52:53 +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/>.
*/
/**
* Analyzer part of inline assembly.
*/
#include <libsolidity/inlineasm/AsmAnalysis.h>
#include <libsolidity/inlineasm/AsmData.h>
#include <libsolidity/inlineasm/AsmScopeFiller.h>
#include <libsolidity/inlineasm/AsmScope.h>
#include <libsolidity/inlineasm/AsmAnalysisInfo.h>
2017-02-15 13:52:53 +00:00
#include <libsolidity/interface/Exceptions.h>
#include <libsolidity/interface/Utils.h>
#include <boost/range/adaptor/reversed.hpp>
#include <memory>
#include <functional>
using namespace std;
using namespace dev;
using namespace dev::solidity;
using namespace dev::solidity::assembly;
AsmAnalyzer::AsmAnalyzer(
AsmAnalysisInfo& _analysisInfo,
ErrorList& _errors,
ExternalIdentifierAccess::Resolver const& _resolver
):
m_resolver(_resolver), m_info(_analysisInfo), m_errors(_errors)
2017-02-15 13:52:53 +00:00
{
}
bool AsmAnalyzer::analyze(Block const& _block)
2017-02-15 13:52:53 +00:00
{
if (!(ScopeFiller(m_info.scopes, m_errors))(_block))
2017-02-15 13:52:53 +00:00
return false;
return (*this)(_block);
2017-02-15 13:52:53 +00:00
}
bool AsmAnalyzer::operator()(Label const& _label)
2017-04-26 10:34:24 +00:00
{
m_info.stackHeightInfo[&_label] = m_stackHeight;
return true;
2017-04-26 10:34:24 +00:00
}
bool AsmAnalyzer::operator()(assembly::Instruction const& _instruction)
{
auto const& info = instructionInfo(_instruction.instruction);
m_stackHeight += info.ret - info.args;
m_info.stackHeightInfo[&_instruction] = m_stackHeight;
return true;
}
bool AsmAnalyzer::operator()(assembly::Literal const& _literal)
2017-02-16 22:44:22 +00:00
{
++m_stackHeight;
if (_literal.kind == assembly::LiteralKind::String && _literal.value.size() > 32)
{
m_errors.push_back(make_shared<Error>(
Error::Type::TypeError,
2017-03-22 12:21:15 +00:00
"String literal too long (" + boost::lexical_cast<std::string>(_literal.value.size()) + " > 32)",
_literal.location
));
2017-02-16 22:44:22 +00:00
return false;
}
m_info.stackHeightInfo[&_literal] = m_stackHeight;
2017-02-16 22:44:22 +00:00
return true;
}
bool AsmAnalyzer::operator()(assembly::Identifier const& _identifier)
2017-02-15 13:52:53 +00:00
{
2017-04-25 11:15:42 +00:00
size_t numErrorsBefore = m_errors.size();
bool success = true;
if (m_currentScope->lookup(_identifier.name, Scope::Visitor(
[&](Scope::Variable const& _var)
2017-02-17 11:03:55 +00:00
{
if (!_var.active)
{
m_errors.push_back(make_shared<Error>(
Error::Type::DeclarationError,
"Variable " + _identifier.name + " used before it was declared.",
_identifier.location
));
success = false;
}
++m_stackHeight;
},
[&](Scope::Label const&)
{
++m_stackHeight;
},
[&](Scope::Function const&)
{
m_errors.push_back(make_shared<Error>(
Error::Type::TypeError,
"Function " + _identifier.name + " used without being called.",
2017-03-22 12:21:15 +00:00
_identifier.location
));
success = false;
2017-02-17 11:03:55 +00:00
}
)))
{
2017-02-17 11:03:55 +00:00
}
else
2017-02-15 13:52:53 +00:00
{
size_t stackSize(-1);
if (m_resolver)
stackSize = m_resolver(_identifier, IdentifierContext::RValue);
if (stackSize == size_t(-1))
{
2017-04-25 11:15:42 +00:00
// Only add an error message if the callback did not do it.
if (numErrorsBefore == m_errors.size())
m_errors.push_back(make_shared<Error>(
Error::Type::DeclarationError,
"Identifier not found.",
_identifier.location
));
success = false;
}
m_stackHeight += stackSize == size_t(-1) ? 1 : stackSize;
2017-02-15 13:52:53 +00:00
}
m_info.stackHeightInfo[&_identifier] = m_stackHeight;
return success;
2017-02-15 13:52:53 +00:00
}
bool AsmAnalyzer::operator()(FunctionalInstruction const& _instr)
{
bool success = true;
for (auto const& arg: _instr.arguments | boost::adaptors::reversed)
{
int const stackHeight = m_stackHeight;
2017-02-15 13:52:53 +00:00
if (!boost::apply_visitor(*this, arg))
success = false;
if (!expectDeposit(1, stackHeight, locationOf(arg)))
success = false;
}
// Parser already checks that the number of arguments is correct.
solAssert(instructionInfo(_instr.instruction.instruction).args == int(_instr.arguments.size()), "");
2017-02-15 13:52:53 +00:00
if (!(*this)(_instr.instruction))
success = false;
m_info.stackHeightInfo[&_instr] = m_stackHeight;
2017-02-15 13:52:53 +00:00
return success;
}
bool AsmAnalyzer::operator()(assembly::Assignment const& _assignment)
2017-02-15 13:52:53 +00:00
{
2017-04-26 10:34:24 +00:00
bool success = checkAssignment(_assignment.variableName, size_t(-1));
m_info.stackHeightInfo[&_assignment] = m_stackHeight;
2017-04-26 10:34:24 +00:00
return success;
2017-02-15 13:52:53 +00:00
}
2017-04-26 10:34:24 +00:00
2017-02-15 15:47:54 +00:00
bool AsmAnalyzer::operator()(FunctionalAssignment const& _assignment)
2017-02-15 13:52:53 +00:00
{
int const stackHeight = m_stackHeight;
bool success = boost::apply_visitor(*this, *_assignment.value);
solAssert(m_stackHeight >= stackHeight, "Negative value size.");
if (!checkAssignment(_assignment.variableName, m_stackHeight - stackHeight))
success = false;
m_info.stackHeightInfo[&_assignment] = m_stackHeight;
return success;
2017-02-15 13:52:53 +00:00
}
bool AsmAnalyzer::operator()(assembly::VariableDeclaration const& _varDecl)
{
2017-04-21 16:01:41 +00:00
int const stackHeight = m_stackHeight;
2017-02-15 13:52:53 +00:00
bool success = boost::apply_visitor(*this, *_varDecl.value);
2017-04-21 16:01:41 +00:00
solAssert(m_stackHeight - stackHeight == 1, "Invalid value size.");
2017-04-26 22:58:34 +00:00
boost::get<Scope::Variable>(m_currentScope->identifiers.at(_varDecl.variable.name)).active = true;
m_info.stackHeightInfo[&_varDecl] = m_stackHeight;
2017-02-17 11:03:55 +00:00
return success;
}
bool AsmAnalyzer::operator()(assembly::FunctionDefinition const& _funDef)
{
Scope& bodyScope = scope(&_funDef.body);
for (auto const& var: _funDef.arguments + _funDef.returns)
2017-04-26 22:58:34 +00:00
boost::get<Scope::Variable>(bodyScope.identifiers.at(var.name)).active = true;
int const stackHeight = m_stackHeight;
m_stackHeight = _funDef.arguments.size() + _funDef.returns.size();
m_virtualVariablesInNextBlock = m_stackHeight;
bool success = (*this)(_funDef.body);
m_stackHeight = stackHeight;
m_info.stackHeightInfo[&_funDef] = m_stackHeight;
return success;
}
bool AsmAnalyzer::operator()(assembly::FunctionCall const& _funCall)
2017-02-17 11:03:55 +00:00
{
bool success = true;
size_t arguments = 0;
size_t returns = 0;
if (!m_currentScope->lookup(_funCall.functionName.name, Scope::Visitor(
[&](Scope::Variable const&)
{
m_errors.push_back(make_shared<Error>(
Error::Type::TypeError,
"Attempt to call variable instead of function.",
_funCall.functionName.location
));
success = false;
},
[&](Scope::Label const&)
{
m_errors.push_back(make_shared<Error>(
Error::Type::TypeError,
"Attempt to call label instead of function.",
_funCall.functionName.location
));
success = false;
},
[&](Scope::Function const& _fun)
{
2017-04-26 22:58:34 +00:00
/// TODO: compare types too
arguments = _fun.arguments.size();
returns = _fun.returns.size();
}
)))
2017-02-15 13:52:53 +00:00
{
m_errors.push_back(make_shared<Error>(
Error::Type::DeclarationError,
"Function not found.",
_funCall.functionName.location
2017-02-15 13:52:53 +00:00
));
success = false;
}
if (success)
{
if (_funCall.arguments.size() != arguments)
{
m_errors.push_back(make_shared<Error>(
Error::Type::TypeError,
"Expected " +
boost::lexical_cast<string>(arguments) +
" arguments but got " +
boost::lexical_cast<string>(_funCall.arguments.size()) +
".",
_funCall.functionName.location
));
2017-02-17 11:03:55 +00:00
success = false;
}
}
2017-02-17 11:03:55 +00:00
for (auto const& arg: _funCall.arguments | boost::adaptors::reversed)
{
int const stackHeight = m_stackHeight;
2017-02-17 11:03:55 +00:00
if (!boost::apply_visitor(*this, arg))
success = false;
if (!expectDeposit(1, stackHeight, locationOf(arg)))
success = false;
}
2017-03-22 18:02:27 +00:00
m_stackHeight += int(returns) - int(arguments);
m_info.stackHeightInfo[&_funCall] = m_stackHeight;
2017-02-17 11:03:55 +00:00
return success;
2017-02-16 22:44:22 +00:00
}
2017-02-15 13:52:53 +00:00
bool AsmAnalyzer::operator()(Block const& _block)
{
bool success = true;
2017-02-17 11:03:55 +00:00
m_currentScope = &scope(&_block);
2017-02-15 13:52:53 +00:00
2017-03-22 18:02:27 +00:00
int const initialStackHeight = m_stackHeight - m_virtualVariablesInNextBlock;
m_virtualVariablesInNextBlock = 0;
2017-02-15 13:52:53 +00:00
for (auto const& s: _block.statements)
if (!boost::apply_visitor(*this, s))
success = false;
for (auto const& identifier: scope(&_block).identifiers)
if (identifier.second.type() == typeid(Scope::Variable))
--m_stackHeight;
2017-03-22 18:02:27 +00:00
int const stackDiff = m_stackHeight - initialStackHeight;
if (stackDiff != 0)
{
m_errors.push_back(make_shared<Error>(
Error::Type::DeclarationError,
"Unbalanced stack at the end of a block: " +
(
stackDiff > 0 ?
to_string(stackDiff) + string(" surplus item(s).") :
to_string(-stackDiff) + string(" missing item(s).")
),
_block.location
));
success = false;
}
2017-02-15 13:52:53 +00:00
m_currentScope = m_currentScope->superScope;
m_info.stackHeightInfo[&_block] = m_stackHeight;
2017-02-15 13:52:53 +00:00
return success;
}
2017-02-17 11:03:55 +00:00
bool AsmAnalyzer::checkAssignment(assembly::Identifier const& _variable, size_t _valueSize)
2017-02-17 11:03:55 +00:00
{
bool success = true;
2017-04-25 11:15:42 +00:00
size_t numErrorsBefore = m_errors.size();
size_t variableSize(-1);
if (Scope::Identifier const* var = m_currentScope->lookup(_variable.name))
{
// Check that it is a variable
if (var->type() != typeid(Scope::Variable))
{
m_errors.push_back(make_shared<Error>(
Error::Type::TypeError,
"Assignment requires variable.",
_variable.location
));
success = false;
}
else if (!boost::get<Scope::Variable>(*var).active)
{
m_errors.push_back(make_shared<Error>(
Error::Type::DeclarationError,
"Variable " + _variable.name + " used before it was declared.",
_variable.location
));
success = false;
}
variableSize = 1;
2017-02-17 11:03:55 +00:00
}
else if (m_resolver)
variableSize = m_resolver(_variable, IdentifierContext::LValue);
if (variableSize == size_t(-1))
{
2017-04-25 11:15:42 +00:00
// Only add message if the callback did not.
if (numErrorsBefore == m_errors.size())
m_errors.push_back(make_shared<Error>(
Error::Type::DeclarationError,
"Variable not found or variable not lvalue.",
_variable.location
));
success = false;
}
if (_valueSize == size_t(-1))
_valueSize = variableSize == size_t(-1) ? 1 : variableSize;
m_stackHeight -= _valueSize;
if (_valueSize != variableSize && variableSize != size_t(-1))
{
m_errors.push_back(make_shared<Error>(
Error::Type::TypeError,
"Variable size (" +
to_string(variableSize) +
") and value size (" +
to_string(_valueSize) +
") do not match.",
_variable.location
));
success = false;
}
return success;
}
bool AsmAnalyzer::expectDeposit(int const _deposit, int const _oldHeight, SourceLocation const& _location)
{
int stackDiff = m_stackHeight - _oldHeight;
if (stackDiff != _deposit)
{
m_errors.push_back(make_shared<Error>(
Error::Type::TypeError,
"Expected instruction(s) to deposit " +
boost::lexical_cast<string>(_deposit) +
" item(s) to the stack, but did deposit " +
boost::lexical_cast<string>(stackDiff) +
" item(s).",
_location
));
return false;
}
else
return true;
2017-02-17 11:03:55 +00:00
}
Scope& AsmAnalyzer::scope(Block const* _block)
{
auto scopePtr = m_info.scopes.at(_block);
solAssert(scopePtr, "Scope requested but not present.");
return *scopePtr;
2017-02-17 11:03:55 +00:00
}