cerc-io/solidity
10
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

Removed signed shift right from the utilities.

Browse Source
This commit is contained in:
chriseth 2018-04-06 16:25:13 +02:00 committed by Alex Beregszaszi
parent 52c9441879
commit 2968639406
6 changed files with 24 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
libsolidity/codegen/ABIFunctions.cpp
View File

@ -371,7 +371,7 @@ string ABIFunctions::conversionFunction(Type const& _from, Type const& _to)
if (toCategory == Type::Category::Integer) if (toCategory == Type::Category::Integer)
body = body =
Whiskers("converted := <convert>(<shift>(value))") Whiskers("converted := <convert>(<shift>(value))")
("shift", shiftRightFunction(256 - from.numBytes() * 8, false)) ("shift", shiftRightFunction(256 - from.numBytes() * 8))
("convert", conversionFunction(IntegerType(from.numBytes() * 8), _to)) ("convert", conversionFunction(IntegerType(from.numBytes() * 8), _to))
.render(); .render();
else else
@ -458,8 +458,8 @@ string ABIFunctions::splitExternalFunctionIdFunction()
} }
)") )")
("functionName", functionName) ("functionName", functionName)
("shr32", shiftRightFunction(32, false)) ("shr32", shiftRightFunction(32))
("shr64", shiftRightFunction(64, false)) ("shr64", shiftRightFunction(64))
.render(); .render();
}); });
} }
@ -831,7 +831,7 @@ string ABIFunctions::abiEncodingFunctionCompactStorageArray(
templ("encodeToMemoryFun", encodeToMemoryFun); templ("encodeToMemoryFun", encodeToMemoryFun);
std::vector<std::map<std::string, std::string>> items(itemsPerSlot); std::vector<std::map<std::string, std::string>> items(itemsPerSlot);
for (size_t i = 0; i < itemsPerSlot; ++i) for (size_t i = 0; i < itemsPerSlot; ++i)
items[i]["shiftRightFun"] = shiftRightFunction(i * storageBytes * 8, false); items[i]["shiftRightFun"] = shiftRightFunction(i * storageBytes * 8);
templ("items", items); templ("items", items);
return templ.render(); return templ.render();
} }
@ -927,7 +927,7 @@ string ABIFunctions::abiEncodingFunctionStruct(
} }
else else
memberTempl("preprocess", ""); memberTempl("preprocess", "");
memberTempl("retrieveValue", shiftRightFunction(intraSlotOffset * 8, false) + "(slotValue)"); memberTempl("retrieveValue", shiftRightFunction(intraSlotOffset * 8) + "(slotValue)");
} }
else else
{ {
@ -1434,14 +1434,15 @@ string ABIFunctions::shiftLeftFunction(size_t _numBits)
} }
} }
string ABIFunctions::shiftRightFunction(size_t _numBits, bool _signed) string ABIFunctions::shiftRightFunction(size_t _numBits)
{ {
solAssert(_numBits < 256, ""); solAssert(_numBits < 256, "");
string functionName = "shift_right_" + to_string(_numBits) + (_signed ? "_signed" : "_unsigned"); // Note that if this is extended with signed shifts,
// the opcodes SAR and SDIV behave differently with regards to rounding!
// NOTE: SAR rounds differently than SDIV string functionName = "shift_right_" + to_string(_numBits) + "_unsigned";
if (m_evmVersion.hasBitwiseShifting() && !_signed) if (m_evmVersion.hasBitwiseShifting())
{ {
return createFunction(functionName, [&]() { return createFunction(functionName, [&]() {
return return
@ -1461,11 +1462,10 @@ string ABIFunctions::shiftRightFunction(size_t _numBits, bool _signed)
return return
Whiskers(R"( Whiskers(R"(
function <functionName>(value) -> newValue { function <functionName>(value) -> newValue {
newValue := <div>(value, <multiplier>) newValue := div(value, <multiplier>)
} }
)") )")
("functionName", functionName) ("functionName", functionName)
("div", _signed ? "sdiv" : "div")
("multiplier", toCompactHexWithPrefix(u256(1) << _numBits)) ("multiplier", toCompactHexWithPrefix(u256(1) << _numBits))
.render(); .render();
}); });

2
libsolidity/codegen/ABIFunctions.h
View File

@ -195,7 +195,7 @@ private:
std::string copyToMemoryFunction(bool _fromCalldata); std::string copyToMemoryFunction(bool _fromCalldata);
std::string shiftLeftFunction(size_t _numBits); std::string shiftLeftFunction(size_t _numBits);
std::string shiftRightFunction(size_t _numBits, bool _signed); std::string shiftRightFunction(size_t _numBits);
/// @returns the name of a function that rounds its input to the next multiple /// @returns the name of a function that rounds its input to the next multiple
/// of 32 or the input if it is a multiple of 32. /// of 32 or the input if it is a multiple of 32.
std::string roundUpFunction(); std::string roundUpFunction();

18
libsolidity/codegen/CompilerUtils.cpp
View File

@ -599,15 +599,15 @@ void CompilerUtils::splitExternalFunctionType(bool _leftAligned)
if (_leftAligned) if (_leftAligned)
{ {
m_context << Instruction::DUP1; m_context << Instruction::DUP1;
rightShiftNumberOnStack(64 + 32, false); rightShiftNumberOnStack(64 + 32);
// <input> <address> // <input> <address>
m_context << Instruction::SWAP1; m_context << Instruction::SWAP1;
rightShiftNumberOnStack(64, false); rightShiftNumberOnStack(64);
} }
else else
{ {
m_context << Instruction::DUP1; m_context << Instruction::DUP1;
rightShiftNumberOnStack(32, false); rightShiftNumberOnStack(32);
m_context << ((u256(1) << 160) - 1) << Instruction::AND << Instruction::SWAP1; m_context << ((u256(1) << 160) - 1) << Instruction::AND << Instruction::SWAP1;
} }
m_context << u256(0xffffffffUL) << Instruction::AND; m_context << u256(0xffffffffUL) << Instruction::AND;
@ -675,7 +675,7 @@ void CompilerUtils::convertType(
// conversion from bytes to integer. no need to clean the high bit // conversion from bytes to integer. no need to clean the high bit
// only to shift right because of opposite alignment // only to shift right because of opposite alignment
IntegerType const& targetIntegerType = dynamic_cast<IntegerType const&>(_targetType); IntegerType const& targetIntegerType = dynamic_cast<IntegerType const&>(_targetType);
rightShiftNumberOnStack(256 - typeOnStack.numBytes() * 8, false); rightShiftNumberOnStack(256 - typeOnStack.numBytes() * 8);
if (targetIntegerType.numBits() < typeOnStack.numBytes() * 8) if (targetIntegerType.numBits() < typeOnStack.numBytes() * 8)
convertType(IntegerType(typeOnStack.numBytes() * 8), _targetType, _cleanupNeeded); convertType(IntegerType(typeOnStack.numBytes() * 8), _targetType, _cleanupNeeded);
} }
@ -1242,7 +1242,7 @@ unsigned CompilerUtils::loadFromMemoryHelper(Type const& _type, bool _fromCallda
bool leftAligned = _type.category() == Type::Category::FixedBytes; bool leftAligned = _type.category() == Type::Category::FixedBytes;
// add leading or trailing zeros by dividing/multiplying depending on alignment // add leading or trailing zeros by dividing/multiplying depending on alignment
int shiftFactor = (32 - numBytes) * 8; int shiftFactor = (32 - numBytes) * 8;
rightShiftNumberOnStack(shiftFactor, false); rightShiftNumberOnStack(shiftFactor);
if (leftAligned) if (leftAligned)
leftShiftNumberOnStack(shiftFactor); leftShiftNumberOnStack(shiftFactor);
} }
@ -1271,14 +1271,14 @@ void CompilerUtils::leftShiftNumberOnStack(unsigned _bits)
m_context << (u256(1) << _bits) << Instruction::MUL; m_context << (u256(1) << _bits) << Instruction::MUL;
} }
void CompilerUtils::rightShiftNumberOnStack(unsigned _bits, bool _isSigned) void CompilerUtils::rightShiftNumberOnStack(unsigned _bits)
{ {
solAssert(_bits < 256, ""); solAssert(_bits < 256, "");
// NOTE: SAR rounds differently than SDIV // NOTE: If we add signed right shift, SAR rounds differently than SDIV
if (m_context.evmVersion().hasBitwiseShifting() && !_isSigned) if (m_context.evmVersion().hasBitwiseShifting())
m_context << _bits << Instruction::SHR; m_context << _bits << Instruction::SHR;
else else
m_context << (u256(1) << _bits) << Instruction::SWAP1 << (_isSigned ? Instruction::SDIV : Instruction::DIV); m_context << (u256(1) << _bits) << Instruction::SWAP1 << Instruction::DIV;
} }
unsigned CompilerUtils::prepareMemoryStore(Type const& _type, bool _padToWords) unsigned CompilerUtils::prepareMemoryStore(Type const& _type, bool _padToWords)

2
libsolidity/codegen/CompilerUtils.h
View File

@ -254,7 +254,7 @@ public:
/// Helper function to shift top value on the stack to the right. /// Helper function to shift top value on the stack to the right.
/// Stack pre: <value> <shift_by_bits> /// Stack pre: <value> <shift_by_bits>
/// Stack post: <shifted_value> /// Stack post: <shifted_value>
void rightShiftNumberOnStack(unsigned _bits, bool _isSigned = false); void rightShiftNumberOnStack(unsigned _bits);
/// Appends code that computes tha Keccak-256 hash of the topmost stack element of 32 byte type. /// Appends code that computes tha Keccak-256 hash of the topmost stack element of 32 byte type.
void computeHashStatic(); void computeHashStatic();

2
libsolidity/codegen/ExpressionCompiler.cpp
View File

@ -548,7 +548,7 @@ bool ExpressionCompiler::visit(FunctionCall const& _functionCall)
if (m_context.runtimeContext()) if (m_context.runtimeContext())
// We have a runtime context, so we need the creation part. // We have a runtime context, so we need the creation part.
utils().rightShiftNumberOnStack(32, false); utils().rightShiftNumberOnStack(32);
else else
// Extract the runtime part. // Extract the runtime part.
m_context << ((u256(1) << 32) - 1) << Instruction::AND; m_context << ((u256(1) << 32) - 1) << Instruction::AND;

2
libsolidity/codegen/LValue.cpp
View File

@ -267,7 +267,7 @@ void StorageItem::storeValue(Type const& _sourceType, SourceLocation const& _loc
else if (m_dataType->category() == Type::Category::FixedBytes) else if (m_dataType->category() == Type::Category::FixedBytes)
{ {
solAssert(_sourceType.category() == Type::Category::FixedBytes, "source not fixed bytes"); solAssert(_sourceType.category() == Type::Category::FixedBytes, "source not fixed bytes");
CompilerUtils(m_context).rightShiftNumberOnStack(256 - 8 * dynamic_cast<FixedBytesType const&>(*m_dataType).numBytes(), false); CompilerUtils(m_context).rightShiftNumberOnStack(256 - 8 * dynamic_cast<FixedBytesType const&>(*m_dataType).numBytes());
} }
else else
{ {