cerc-io/solidity
11
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

reduce unnecessary solidity:: namespace

Browse Source
This commit is contained in:
Dimitry
2016-04-04 15:41:35 +04:00
parent d43d4347bf
commit d2cee6f9c6
14 changed files with 658 additions and 658 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libsolidity/codegen/ExpressionCompiler.cpp
+121 -121
View File
@@ -75,7 +75,7 @@ void ExpressionCompiler::appendConstStateVariableAccessor(VariableDeclaration co
utils().convertType(*_varDecl.value()->annotation().type, *_varDecl.annotation().type);
// append return
m_context << solidity::dupInstruction(_varDecl.annotation().type->sizeOnStack() + 1);
m_context << dupInstruction(_varDecl.annotation().type->sizeOnStack() + 1);
m_context.appendJump(eth::AssemblyItem::JumpType::OutOfFunction);
}
@@ -103,13 +103,13 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const&
"Accessors for mapping with dynamically-sized keys not yet implemented."
);
// pop offset
m_context << solidity::Instruction::POP;
m_context << Instruction::POP;
// move storage offset to memory.
utils().storeInMemory(32);
// move key to memory.
utils().copyToStackTop(paramTypes.size() - i, 1);
utils().storeInMemory(0);
m_context << u256(64) << u256(0) << solidity::Instruction::SHA3;
m_context << u256(64) << u256(0) << Instruction::SHA3;
// push offset
m_context << u256(0);
returnType = mappingType->valueType();
@@ -117,7 +117,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const&
else if (auto arrayType = dynamic_cast<ArrayType const*>(returnType.get()))
{
// pop offset
m_context << solidity::Instruction::POP;
m_context << Instruction::POP;
utils().copyToStackTop(paramTypes.size() - i + 1, 1);
ArrayUtils(m_context).accessIndex(*arrayType);
returnType = arrayType->baseType();
@@ -127,12 +127,12 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const&
}
// remove index arguments.
if (paramTypes.size() == 1)
m_context << solidity::Instruction::SWAP2 << solidity::Instruction::POP << solidity::Instruction::SWAP1;
m_context << Instruction::SWAP2 << Instruction::POP << Instruction::SWAP1;
else if (paramTypes.size() >= 2)
{
m_context << solidity::swapInstruction(paramTypes.size());
m_context << solidity::Instruction::POP;
m_context << solidity::swapInstruction(paramTypes.size());
m_context << swapInstruction(paramTypes.size());
m_context << Instruction::POP;
m_context << swapInstruction(paramTypes.size());
utils().popStackSlots(paramTypes.size() - 1);
}
unsigned retSizeOnStack = 0;
@@ -141,7 +141,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const&
if (StructType const* structType = dynamic_cast<StructType const*>(returnType.get()))
{
// remove offset
m_context << solidity::Instruction::POP;
m_context << Instruction::POP;
auto const& names = accessorType.returnParameterNames();
// struct
for (size_t i = 0; i < names.size(); ++i)
@@ -152,7 +152,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const&
if (!arrayType->isByteArray())
continue;
pair<u256, unsigned> const& offsets = structType->storageOffsetsOfMember(names[i]);
m_context << solidity::Instruction::DUP1 << u256(offsets.first) << solidity::Instruction::ADD << u256(offsets.second);
m_context << Instruction::DUP1 << u256(offsets.first) << Instruction::ADD << u256(offsets.second);
TypePointer memberType = structType->memberType(names[i]);
StorageItem(m_context, *memberType).retrieveValue(SourceLocation(), true);
utils().convertType(*memberType, *returnTypes[i]);
@@ -160,7 +160,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const&
retSizeOnStack += returnTypes[i]->sizeOnStack();
}
// remove slot
m_context << solidity::Instruction::POP;
m_context << Instruction::POP;
}
else
{
@@ -172,7 +172,7 @@ void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const&
}
solAssert(retSizeOnStack == utils().sizeOnStack(returnTypes), "");
solAssert(retSizeOnStack <= 15, "Stack is too deep.");
m_context << solidity::dupInstruction(retSizeOnStack + 1);
m_context << dupInstruction(retSizeOnStack + 1);
m_context.appendJump(eth::AssemblyItem::JumpType::OutOfFunction);
}
@@ -226,7 +226,7 @@ bool ExpressionCompiler::visit(Assignment const& _assignment)
solAssert(itemSize + lvalueSize <= 16, "Stack too deep, try removing local variables.");
// value [lvalue_ref] updated_value
for (unsigned i = 0; i < itemSize; ++i)
m_context << solidity::swapInstruction(itemSize + lvalueSize) << solidity::Instruction::POP;
m_context << swapInstruction(itemSize + lvalueSize) << Instruction::POP;
}
}
m_currentLValue->storeValue(*type, _assignment.location());
@@ -243,7 +243,7 @@ bool ExpressionCompiler::visit(TupleExpression const& _tuple)
solAssert(!arrayType.isDynamicallySized(), "Cannot create dynamically sized inline array.");
m_context << max(u256(32u), arrayType.memorySize());
utils().allocateMemory();
m_context << solidity::Instruction::DUP1;
m_context << Instruction::DUP1;
for (auto const& component: _tuple.components())
{
@@ -252,7 +252,7 @@ bool ExpressionCompiler::visit(TupleExpression const& _tuple)
utils().storeInMemoryDynamic(*arrayType.baseType(), true);
}
m_context << solidity::Instruction::POP;
m_context << Instruction::POP;
}
else
{
@@ -298,13 +298,13 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation)
switch (_unaryOperation.getOperator())
{
case Token::Not: // !
m_context << solidity::Instruction::ISZERO;
m_context << Instruction::ISZERO;
break;
case Token::BitNot: // ~
m_context << solidity::Instruction::NOT;
m_context << Instruction::NOT;
break;
case Token::After: // after
m_context << solidity::Instruction::TIMESTAMP << solidity::Instruction::ADD;
m_context << Instruction::TIMESTAMP << Instruction::ADD;
break;
case Token::Delete: // delete
solAssert(!!m_currentLValue, "LValue not retrieved.");
@@ -319,20 +319,20 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation)
{
// store value for later
solAssert(_unaryOperation.annotation().type->sizeOnStack() == 1, "Stack size != 1 not implemented.");
m_context << solidity::Instruction::DUP1;
m_context << Instruction::DUP1;
if (m_currentLValue->sizeOnStack() > 0)
for (unsigned i = 1 + m_currentLValue->sizeOnStack(); i > 0; --i)
m_context << solidity::swapInstruction(i);
m_context << swapInstruction(i);
}
m_context << u256(1);
if (_unaryOperation.getOperator() == Token::Inc)
m_context << solidity::Instruction::ADD;
m_context << Instruction::ADD;
else
m_context << solidity::Instruction::SWAP1 << solidity::Instruction::SUB;
m_context << Instruction::SWAP1 << Instruction::SUB;
// Stack for prefix: [ref...] (*ref)+-1
// Stack for postfix: *ref [ref...] (*ref)+-1
for (unsigned i = m_currentLValue->sizeOnStack(); i > 0; --i)
m_context << solidity::swapInstruction(i);
m_context << swapInstruction(i);
m_currentLValue->storeValue(
*_unaryOperation.annotation().type, _unaryOperation.location(),
!_unaryOperation.isPrefixOperation());
@@ -342,7 +342,7 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation)
// unary add, so basically no-op
break;
case Token::Sub: // -
m_context << u256(0) << solidity::Instruction::SUB;
m_context << u256(0) << Instruction::SUB;
break;
default:
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Invalid unary operator: " +
@@ -452,7 +452,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
m_context << max(u256(32u), structType.memorySize());
utils().allocateMemory();
m_context << solidity::Instruction::DUP1;
m_context << Instruction::DUP1;
for (unsigned i = 0; i < arguments.size(); ++i)
{
@@ -460,7 +460,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
utils().convertType(*arguments[i]->annotation().type, *functionType->parameterTypes()[i]);
utils().storeInMemoryDynamic(*functionType->parameterTypes()[i]);
}
m_context << solidity::Instruction::POP;
m_context << Instruction::POP;
}
else
{
@@ -518,21 +518,21 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
utils().fetchFreeMemoryPointer();
// pushes size
eth::AssemblyItem subroutine = m_context.addSubroutine(assembly);
m_context << solidity::Instruction::DUP1 << subroutine;
m_context << solidity::Instruction::DUP4 << solidity::Instruction::CODECOPY;
m_context << Instruction::DUP1 << subroutine;
m_context << Instruction::DUP4 << Instruction::CODECOPY;
m_context << solidity::Instruction::ADD;
m_context << Instruction::ADD;
utils().encodeToMemory(argumentTypes, function.parameterTypes());
// now on stack: memory_end_ptr
// need: size, offset, endowment
utils().toSizeAfterFreeMemoryPointer();
if (function.valueSet())
m_context << solidity::dupInstruction(3);
m_context << dupInstruction(3);
else
m_context << u256(0);
m_context << solidity::Instruction::CREATE;
m_context << Instruction::CREATE;
if (function.valueSet())
m_context << solidity::swapInstruction(1) << solidity::Instruction::POP;
m_context << swapInstruction(1) << Instruction::POP;
break;
}
case Location::SetGas:
@@ -546,9 +546,9 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
// Its values of gasSet and valueSet is equal to the original function's though.
unsigned stackDepth = (function.gasSet() ? 1 : 0) + (function.valueSet() ? 1 : 0);
if (stackDepth > 0)
m_context << solidity::swapInstruction(stackDepth);
m_context << swapInstruction(stackDepth);
if (function.gasSet())
m_context << solidity::Instruction::POP;
m_context << Instruction::POP;
break;
}
case Location::SetValue:
@@ -557,7 +557,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
// Note that function is not the original function, but the ".value" function.
// Its values of gasSet and valueSet is equal to the original function's though.
if (function.valueSet())
m_context << solidity::Instruction::POP;
m_context << Instruction::POP;
arguments.front()->accept(*this);
break;
case Location::Send:
@@ -586,7 +586,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
case Location::Selfdestruct:
arguments.front()->accept(*this);
utils().convertType(*arguments.front()->annotation().type, *function.parameterTypes().front(), true);
m_context << solidity::Instruction::SUICIDE;
m_context << Instruction::SUICIDE;
break;
case Location::SHA3:
{
@@ -599,7 +599,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
utils().fetchFreeMemoryPointer();
utils().encodeToMemory(argumentTypes, TypePointers(), function.padArguments(), true);
utils().toSizeAfterFreeMemoryPointer();
m_context << solidity::Instruction::SHA3;
m_context << Instruction::SHA3;
break;
}
case Location::Log0:
@@ -622,7 +622,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
false,
true);
utils().toSizeAfterFreeMemoryPointer();
m_context << solidity::logInstruction(logNumber);
m_context << logInstruction(logNumber);
break;
}
case Location::Event:
@@ -646,7 +646,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
true
);
utils().toSizeAfterFreeMemoryPointer();
m_context << solidity::Instruction::SHA3;
m_context << Instruction::SHA3;
}
else
utils().convertType(
@@ -676,14 +676,14 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
utils().encodeToMemory(nonIndexedArgTypes, nonIndexedParamTypes);
// need: topic1 ... topicn memsize memstart
utils().toSizeAfterFreeMemoryPointer();
m_context << solidity::logInstruction(numIndexed);
m_context << logInstruction(numIndexed);
break;
}
case Location::BlockHash:
{
arguments[0]->accept(*this);
utils().convertType(*arguments[0]->annotation().type, *function.parameterTypes()[0], true);
m_context << solidity::Instruction::BLOCKHASH;
m_context << Instruction::BLOCKHASH;
break;
}
case Location::AddMod:
@@ -695,9 +695,9 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
utils().convertType(*arguments[2 - i]->annotation().type, IntegerType(256));
}
if (function.location() == Location::AddMod)
m_context << solidity::Instruction::ADDMOD;
m_context << Instruction::ADDMOD;
else
m_context << solidity::Instruction::MULMOD;
m_context << Instruction::MULMOD;
break;
}
case Location::ECRecover:
@@ -710,7 +710,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
{Location::RIPEMD160, 3}};
m_context << contractAddresses.find(function.location())->second;
for (unsigned i = function.sizeOnStack(); i > 0; --i)
m_context << solidity::swapInstruction(i);
m_context << swapInstruction(i);
appendExternalFunctionCall(function, arguments);
break;
}
@@ -727,13 +727,13 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
make_shared<ArrayType>(DataLocation::Storage);
// get the current length
ArrayUtils(m_context).retrieveLength(*arrayType);
m_context << solidity::Instruction::DUP1;
m_context << Instruction::DUP1;
// stack: ArrayReference currentLength currentLength
m_context << u256(1) << solidity::Instruction::ADD;
m_context << u256(1) << Instruction::ADD;
// stack: ArrayReference currentLength newLength
m_context << solidity::Instruction::DUP3 << solidity::Instruction::DUP2;
m_context << Instruction::DUP3 << Instruction::DUP2;
ArrayUtils(m_context).resizeDynamicArray(*arrayType);
m_context << solidity::Instruction::SWAP2 << solidity::Instruction::SWAP1;
m_context << Instruction::SWAP2 << Instruction::SWAP1;
// stack: newLength ArrayReference oldLength
ArrayUtils(m_context).accessIndex(*arrayType, false);
@@ -766,36 +766,36 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
// Stack: requested_length
// Allocate at max(MSIZE, freeMemoryPointer)
utils().fetchFreeMemoryPointer();
m_context << solidity::Instruction::DUP1 << solidity::Instruction::MSIZE;
m_context << solidity::Instruction::LT;
m_context << Instruction::DUP1 << Instruction::MSIZE;
m_context << Instruction::LT;
auto initialise = m_context.appendConditionalJump();
// Free memory pointer does not point to empty memory, use MSIZE.
m_context << solidity::Instruction::POP;
m_context << solidity::Instruction::MSIZE;
m_context << Instruction::POP;
m_context << Instruction::MSIZE;
m_context << initialise;
// Stack: requested_length memptr
m_context << solidity::Instruction::SWAP1;
m_context << Instruction::SWAP1;
// Stack: memptr requested_length
// store length
m_context << solidity::Instruction::DUP1 << solidity::Instruction::DUP3 << solidity::Instruction::MSTORE;
m_context << Instruction::DUP1 << Instruction::DUP3 << Instruction::MSTORE;
// Stack: memptr requested_length
// update free memory pointer
m_context << solidity::Instruction::DUP1 << arrayType.baseType()->memoryHeadSize();
m_context << solidity::Instruction::MUL << u256(32) << solidity::Instruction::ADD;
m_context << solidity::Instruction::DUP3 << solidity::Instruction::ADD;
m_context << Instruction::DUP1 << arrayType.baseType()->memoryHeadSize();
m_context << Instruction::MUL << u256(32) << Instruction::ADD;
m_context << Instruction::DUP3 << Instruction::ADD;
utils().storeFreeMemoryPointer();
// Stack: memptr requested_length
// We only have to initialise if the base type is a not a value type.
if (dynamic_cast<ReferenceType const*>(arrayType.baseType().get()))
{
m_context << solidity::Instruction::DUP2 << u256(32) << solidity::Instruction::ADD;
m_context << Instruction::DUP2 << u256(32) << Instruction::ADD;
utils().zeroInitialiseMemoryArray(arrayType);
m_context << solidity::Instruction::POP;
m_context << Instruction::POP;
}
else
m_context << solidity::Instruction::POP;
m_context << Instruction::POP;
break;
}
default:
@@ -876,7 +876,7 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
IntegerType(0, IntegerType::Modifier::Address),
true
);
m_context << solidity::Instruction::BALANCE;
m_context << Instruction::BALANCE;
}
else if ((set<string>{"send", "call", "callcode", "delegatecall"}).count(member))
utils().convertType(
@@ -894,30 +894,30 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
case Type::Category::Magic:
// we can ignore the kind of magic and only look at the name of the member
if (member == "coinbase")
m_context << solidity::Instruction::COINBASE;
m_context << Instruction::COINBASE;
else if (member == "timestamp")
m_context << solidity::Instruction::TIMESTAMP;
m_context << Instruction::TIMESTAMP;
else if (member == "difficulty")
m_context << solidity::Instruction::DIFFICULTY;
m_context << Instruction::DIFFICULTY;
else if (member == "number")
m_context << solidity::Instruction::NUMBER;
m_context << Instruction::NUMBER;
else if (member == "gaslimit")
m_context << solidity::Instruction::GASLIMIT;
m_context << Instruction::GASLIMIT;
else if (member == "sender")
m_context << solidity::Instruction::CALLER;
m_context << Instruction::CALLER;
else if (member == "value")
m_context << solidity::Instruction::CALLVALUE;
m_context << Instruction::CALLVALUE;
else if (member == "origin")
m_context << solidity::Instruction::ORIGIN;
m_context << Instruction::ORIGIN;
else if (member == "gas")
m_context << solidity::Instruction::GAS;
m_context << Instruction::GAS;
else if (member == "gasprice")
m_context << solidity::Instruction::GASPRICE;
m_context << Instruction::GASPRICE;
else if (member == "data")
m_context << u256(0) << solidity::Instruction::CALLDATASIZE;
m_context << u256(0) << Instruction::CALLDATASIZE;
else if (member == "sig")
m_context << u256(0) << solidity::Instruction::CALLDATALOAD
<< (u256(0xffffffff) << (256 - 32)) << solidity::Instruction::AND;
m_context << u256(0) << Instruction::CALLDATALOAD
<< (u256(0xffffffff) << (256 - 32)) << Instruction::AND;
else
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown magic member."));
break;
@@ -929,13 +929,13 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
case DataLocation::Storage:
{
pair<u256, unsigned> const& offsets = type.storageOffsetsOfMember(member);
m_context << offsets.first << solidity::Instruction::ADD << u256(offsets.second);
m_context << offsets.first << Instruction::ADD << u256(offsets.second);
setLValueToStorageItem(_memberAccess);
break;
}
case DataLocation::Memory:
{
m_context << type.memoryOffsetOfMember(member) << solidity::Instruction::ADD;
m_context << type.memoryOffsetOfMember(member) << Instruction::ADD;
setLValue<MemoryItem>(_memberAccess, *_memberAccess.annotation().type);
break;
}
@@ -986,13 +986,13 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
switch (type.location())
{
case DataLocation::CallData:
m_context << solidity::Instruction::SWAP1 << solidity::Instruction::POP;
m_context << Instruction::SWAP1 << Instruction::POP;
break;
case DataLocation::Storage:
setLValue<StorageArrayLength>(_memberAccess, type);
break;
case DataLocation::Memory:
m_context << solidity::Instruction::MLOAD;
m_context << Instruction::MLOAD;
break;
}
}
@@ -1046,7 +1046,7 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
false,
true
);
m_context << solidity::Instruction::SWAP1;
m_context << Instruction::SWAP1;
utils().storeInMemoryDynamic(IntegerType(256));
utils().toSizeAfterFreeMemoryPointer();
}
@@ -1054,12 +1054,12 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
{
m_context << u256(0); // memory position
appendExpressionCopyToMemory(*keyType, *_indexAccess.indexExpression());
m_context << solidity::Instruction::SWAP1;
m_context << Instruction::SWAP1;
solAssert(CompilerUtils::freeMemoryPointer >= 0x40, "");
utils().storeInMemoryDynamic(IntegerType(256));
m_context << u256(0);
}
m_context << solidity::Instruction::SHA3;
m_context << Instruction::SHA3;
m_context << u256(0);
setLValueToStorageItem(_indexAccess);
}
@@ -1109,12 +1109,12 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
// stack layout: <value> <index>
// check out-of-bounds access
m_context << u256(fixedBytesType.numBytes());
m_context << solidity::Instruction::DUP2 << solidity::Instruction::LT << solidity::Instruction::ISZERO;
m_context << Instruction::DUP2 << Instruction::LT << Instruction::ISZERO;
// out-of-bounds access throws exception
m_context.appendConditionalJumpTo(m_context.errorTag());
m_context << solidity::Instruction::BYTE;
m_context << (u256(1) << (256 - 8)) << solidity::Instruction::MUL;
m_context << Instruction::BYTE;
m_context << (u256(1) << (256 - 8)) << Instruction::MUL;
}
else if (baseType.category() == Type::Category::TypeType)
{
@@ -1139,11 +1139,11 @@ void ExpressionCompiler::endVisit(Identifier const& _identifier)
case Type::Category::Contract:
// "this" or "super"
if (!dynamic_cast<ContractType const&>(*magicVar->type()).isSuper())
m_context << solidity::Instruction::ADDRESS;
m_context << Instruction::ADDRESS;
break;
case Type::Category::Integer:
// "now"
m_context << solidity::Instruction::TIMESTAMP;
m_context << Instruction::TIMESTAMP;
break;
default:
break;
@@ -1208,11 +1208,11 @@ void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation const& _binaryO
solAssert(c_op == Token::Or || c_op == Token::And, "");
_binaryOperation.leftExpression().accept(*this);
m_context << solidity::Instruction::DUP1;
m_context << Instruction::DUP1;
if (c_op == Token::And)
m_context << solidity::Instruction::ISZERO;
m_context << Instruction::ISZERO;
eth::AssemblyItem endLabel = m_context.appendConditionalJump();
m_context << solidity::Instruction::POP;
m_context << Instruction::POP;
_binaryOperation.rightExpression().accept(*this);
m_context << endLabel;
}
@@ -1221,9 +1221,9 @@ void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type
{
if (_operator == Token::Equal || _operator == Token::NotEqual)
{
m_context << solidity::Instruction::EQ;
m_context << Instruction::EQ;
if (_operator == Token::NotEqual)
m_context << solidity::Instruction::ISZERO;
m_context << Instruction::ISZERO;
}
else
{
@@ -1235,19 +1235,19 @@ void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type
{
case Token::GreaterThanOrEqual:
m_context <<
(isSigned ? solidity::Instruction::SLT : solidity::Instruction::LT) <<
solidity::Instruction::ISZERO;
(isSigned ? Instruction::SLT : Instruction::LT) <<
Instruction::ISZERO;
break;
case Token::LessThanOrEqual:
m_context <<
(isSigned ? solidity::Instruction::SGT : solidity::Instruction::GT) <<
solidity::Instruction::ISZERO;
(isSigned ? Instruction::SGT : Instruction::GT) <<
Instruction::ISZERO;
break;
case Token::GreaterThan:
m_context << (isSigned ? solidity::Instruction::SGT : solidity::Instruction::GT);
m_context << (isSigned ? Instruction::SGT : Instruction::GT);
break;
case Token::LessThan:
m_context << (isSigned ? solidity::Instruction::SLT : solidity::Instruction::LT);
m_context << (isSigned ? Instruction::SLT : Instruction::LT);
break;
default:
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown comparison operator."));
@@ -1275,22 +1275,22 @@ void ExpressionCompiler::appendArithmeticOperatorCode(Token::Value _operator, Ty
switch (_operator)
{
case Token::Add:
m_context << solidity::Instruction::ADD;
m_context << Instruction::ADD;
break;
case Token::Sub:
m_context << solidity::Instruction::SUB;
m_context << Instruction::SUB;
break;
case Token::Mul:
m_context << solidity::Instruction::MUL;
m_context << Instruction::MUL;
break;
case Token::Div:
m_context << (c_isSigned ? solidity::Instruction::SDIV : solidity::Instruction::DIV);
m_context << (c_isSigned ? Instruction::SDIV : Instruction::DIV);
break;
case Token::Mod:
m_context << (c_isSigned ? solidity::Instruction::SMOD : solidity::Instruction::MOD);
m_context << (c_isSigned ? Instruction::SMOD : Instruction::MOD);
break;
case Token::Exp:
m_context << solidity::Instruction::EXP;
m_context << Instruction::EXP;
break;
default:
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown arithmetic operator."));
@@ -1302,13 +1302,13 @@ void ExpressionCompiler::appendBitOperatorCode(Token::Value _operator)
switch (_operator)
{
case Token::BitOr:
m_context << solidity::Instruction::OR;
m_context << Instruction::OR;
break;
case Token::BitAnd:
m_context << solidity::Instruction::AND;
m_context << Instruction::AND;
break;
case Token::BitXor:
m_context << solidity::Instruction::XOR;
m_context << Instruction::XOR;
break;
default:
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown bit operator."));
@@ -1392,7 +1392,7 @@ void ExpressionCompiler::appendExternalFunctionCall(
true
);
for (unsigned i = 0; i < gasValueSize; ++i)
m_context << solidity::swapInstruction(gasValueSize - i);
m_context << swapInstruction(gasValueSize - i);
gasStackPos++;
valueStackPos++;
}
@@ -1411,7 +1411,7 @@ void ExpressionCompiler::appendExternalFunctionCall(
utils().fetchFreeMemoryPointer();
if (!_functionType.isBareCall() || manualFunctionId)
{
m_context << solidity::dupInstruction(2 + gasValueSize + CompilerUtils::sizeOnStack(argumentTypes));
m_context << dupInstruction(2 + gasValueSize + CompilerUtils::sizeOnStack(argumentTypes));
utils().storeInMemoryDynamic(IntegerType(8 * CompilerUtils::dataStartOffset), false);
}
// If the function takes arbitrary parameters, copy dynamic length data in place.
@@ -1437,21 +1437,21 @@ void ExpressionCompiler::appendExternalFunctionCall(
// put on stack: <size of output> <memory pos of output> <size of input> <memory pos of input>
m_context << u256(retSize);
utils().fetchFreeMemoryPointer();
m_context << solidity::Instruction::DUP1 << solidity::Instruction::DUP4 << solidity::Instruction::SUB;
m_context << solidity::Instruction::DUP2;
m_context << Instruction::DUP1 << Instruction::DUP4 << Instruction::SUB;
m_context << Instruction::DUP2;
// CALL arguments: outSize, outOff, inSize, inOff (already present up to here)
// [value,] addr, gas (stack top)
if (isDelegateCall)
solAssert(!_functionType.valueSet(), "Value set for delegatecall");
else if (_functionType.valueSet())
m_context << solidity::dupInstruction(m_context.baseToCurrentStackOffset(valueStackPos));
m_context << dupInstruction(m_context.baseToCurrentStackOffset(valueStackPos));
else
m_context << u256(0);
m_context << solidity::dupInstruction(m_context.baseToCurrentStackOffset(contractStackPos));
m_context << dupInstruction(m_context.baseToCurrentStackOffset(contractStackPos));
if (_functionType.gasSet())
m_context << solidity::dupInstruction(m_context.baseToCurrentStackOffset(gasStackPos));
m_context << dupInstruction(m_context.baseToCurrentStackOffset(gasStackPos));
else
{
eth::EVMSchedule schedule;
@@ -1464,15 +1464,15 @@ void ExpressionCompiler::appendExternalFunctionCall(
gasNeededByCaller += schedule.callNewAccountGas; // we never know
m_context <<
gasNeededByCaller <<
solidity::Instruction::GAS <<
solidity::Instruction::SUB;
Instruction::GAS <<
Instruction::SUB;
}
if (isDelegateCall)
m_context << solidity::Instruction::DELEGATECALL;
m_context << Instruction::DELEGATECALL;
else if (isCallCode)
m_context << solidity::Instruction::CALLCODE;
m_context << Instruction::CALLCODE;
else
m_context << solidity::Instruction::CALL;
m_context << Instruction::CALL;
unsigned remainsSize =
2 + // contract address, input_memory_end
@@ -1481,11 +1481,11 @@ void ExpressionCompiler::appendExternalFunctionCall(
(!_functionType.isBareCall() || manualFunctionId);
if (returnSuccessCondition)
m_context << solidity::swapInstruction(remainsSize);
m_context << swapInstruction(remainsSize);
else
{
//Propagate error condition (if CALL pushes 0 on stack).
m_context << solidity::Instruction::ISZERO;
m_context << Instruction::ISZERO;
m_context.appendConditionalJumpTo(m_context.errorTag());
}
@@ -1515,7 +1515,7 @@ void ExpressionCompiler::appendExternalFunctionCall(
if (memoryNeeded)
utils().storeFreeMemoryPointer();
else
m_context << solidity::Instruction::POP;
m_context << Instruction::POP;
}
}