From aa6f33db2c20a55c72cbef834b255d029c7adc44 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Thu, 20 Apr 2017 12:57:02 +0100 Subject: Use signed/unsigned types in low-level functions --- docs/julia.rst | 144 +++++++++++++++++++++++++++++---------------------------- 1 file changed, 73 insertions(+), 71 deletions(-) (limited to 'docs') diff --git a/docs/julia.rst b/docs/julia.rst index bd8e35a9..98b19662 100644 --- a/docs/julia.rst +++ b/docs/julia.rst @@ -213,86 +213,88 @@ The following functions must be available: +---------------------------------------------------------------------------------------------------------------+ | *Arithmetics* | +---------------------------------------------------------------------------------------------------------------+ -| add256(x:256, y:256) -> z:256 | x + y | +| addu256(x:u256, y:u256) -> z:u256 | x + y | +---------------------------------------------------------------------------------------------------------------+ -| sub256(x:256, y:256) -> z:256 | x - y | +| subu256(x:u256, y:u256) -> z:u256 | x - y | +---------------------------------------------------------------------------------------------------------------+ -| mul256(x:256, y:256) -> z:256 | x * y | +| mulu256(x:u256, y:u256) -> z:u256 | x * y | +---------------------------------------------------------------------------------------------------------------+ -| div256(x:256, y:256) -> z:256 | x / y | +| divu256(x:u256, y:u256) -> z:u256 | x / y | +---------------------------------------------------------------------------------------------------------------+ -| sdiv256(x:256, y:256) -> z:256 | x / y, for signed numbers in two's complement | +| divs256(x:s256, y:s256) -> z:s256 | x / y, for signed numbers in two's complement | +---------------------------------------------------------------------------------------------------------------+ -| mod256(x:256, y:256) -> z:256 | x % y | +| modu256(x:u256, y:u256) -> z:u256 | x % y | +---------------------------------------------------------------------------------------------------------------+ -| smod256(x:256, y:256) -> z:256 | x % y, for signed numbers in two's complement | +| mods256(x:s256, y:s256) -> z:s256 | x % y, for signed numbers in two's complement | +---------------------------------------------------------------------------------------------------------------+ -| signextend256(i:256, x:256) -> z:256 | sign extend from (i*8+7)th bit counting from least significant | +| signextendu256(i:u256, x:u256) -> z:u256 | sign extend from (i*8+7)th bit counting from least significant | +---------------------------------------------------------------------------------------------------------------+ -| exp256(x:256, y:256) -> z:256 | x to the power of y | +| expu256(x:u256, y:u256) -> z:u256 | x to the power of y | +---------------------------------------------------------------------------------------------------------------+ -| addmod256(x:256, y:256, m:256) -> z:256 | (x + y) % m with arbitrary precision arithmetics | +| addmodu256(x:u256, y:u256, m:u256) -> z:u256| (x + y) % m with arbitrary precision arithmetics | +---------------------------------------------------------------------------------------------------------------+ -| mulmod256(x:256, y:256, m:256) -> z:256 | (x * y) % m with arbitrary precision arithmetics | +| mulmodu256(x:u256, y:u256, m:u256) -> z:u256| (x * y) % m with arbitrary precision arithmetics | +---------------------------------------------------------------------------------------------------------------+ -| lt256(x:256, y:256) -> z:bool | 1 if x < y, 0 otherwise | +| ltu256(x:u256, y:u256) -> z:bool | 1 if x < y, 0 otherwise | +---------------------------------------------------------------------------------------------------------------+ -| gt256(x:256, y:256) -> z:bool | 1 if x > y, 0 otherwise | +| gtu256(x:u256, y:u256) -> z:bool | 1 if x > y, 0 otherwise | +---------------------------------------------------------------------------------------------------------------+ -| slt256(x:256, y:256) -> z:bool | 1 if x < y, 0 otherwise, for signed numbers in two's complement | +| sltu256(x:s256, y:s256) -> z:bool | 1 if x < y, 0 otherwise, for signed numbers in two's complement | +---------------------------------------------------------------------------------------------------------------+ -| sgt256(x:256, y:256) -> z:bool | 1 if x > y, 0 otherwise, for signed numbers in two's complement | +| sgtu256(x:s256, y:s256) -> z:bool | 1 if x > y, 0 otherwise, for signed numbers in two's complement | +---------------------------------------------------------------------------------------------------------------+ -| eq256(x:256, y:256) -> z:bool | 1 if x == y, 0 otherwise | +| equ256(x:u256, y:u256) -> z:bool | 1 if x == y, 0 otherwise | +---------------------------------------------------------------------------------------------------------------+ -| not256(x:256) -> z:256 | ~x, every bit of x is negated | +| notu256(x:u256) -> z:u256 | ~x, every bit of x is negated | +---------------------------------------------------------------------------------------------------------------+ -| and256(x:256, y:256) -> z:256 | bitwise and of x and y | +| andu256(x:u256, y:u256) -> z:u256 | bitwise and of x and y | +---------------------------------------------------------------------------------------------------------------+ -| or256(x:256, y:256) -> z:256 | bitwise or of x and y | +| oru256(x:u256, y:u256) -> z:u256 | bitwise or of x and y | +---------------------------------------------------------------------------------------------------------------+ -| xor256(x:256, y:256) -> z:256 | bitwise xor of x and y | +| xoru256(x:u256, y:u256) -> z:u256 | bitwise xor of x and y | +---------------------------------------------------------------------------------------------------------------+ -| shl256(x:256, y:256) -> z:256 | logical left shift of x by y | +| shlu256(x:u256, y:u256) -> z:u256 | logical left shift of x by y | +---------------------------------------------------------------------------------------------------------------+ -| shr256(x:256, y:256) -> z:256 | logical right shift of x by y | +| shru256(x:u256, y:u256) -> z:u256 | logical right shift of x by y | +---------------------------------------------------------------------------------------------------------------+ -| sar256(x:256, y:256) -> z:256 | arithmetic right shift of x by y | +| saru256(x:u256, y:u256) -> z:u256 | arithmetic right shift of x by y | +---------------------------------------------------------------------------------------------------------------+ -| byte(n:256, x:256) -> v:256 | nth byte of x, where the most significant byte is the 0th byte | +| byte(n:u256, x:u256) -> v:u256 | nth byte of x, where the most significant byte is the 0th byte | | Cannot this be just replaced by and256(shr256(n, x), 0xff) and let it be optimised out by the EVM backend? | +---------------------------------------------------------------------------------------------------------------+ | *Memory and storage* | +---------------------------------------------------------------------------------------------------------------+ -| mload(p:256) -> v:256 | mem[p..(p+32)) | +| mload(p:u256) -> v:u256 | mem[p..(p+32)) | +---------------------------------------------------------------------------------------------------------------+ -| mstore(p:256, v:256) | mem[p..(p+32)) := v | +| mstore(p:u256, v:u256) | mem[p..(p+32)) := v | +---------------------------------------------------------------------------------------------------------------+ -| mstore8(p:256, v:256) | mem[p] := v & 0xff - only modifies a single byte | +| mstore8(p:u256, v:u256) | mem[p] := v & 0xff - only modifies a single byte | +---------------------------------------------------------------------------------------------------------------+ -| sload(p:256) -> v:256 | storage[p] | +| sload(p:u256) -> v:u256 | storage[p] | +---------------------------------------------------------------------------------------------------------------+ -| sstore(p:256, v:256) | storage[p] := v | +| sstore(p:u256, v:u256) | storage[p] := v | +---------------------------------------------------------------------------------------------------------------+ -| msize() -> size:256 | size of memory, i.e. largest accessed memory index, albeit due | +| msize() -> size:u256 | size of memory, i.e. largest accessed memory index, albeit due | | | due to the memory extension function, which extends by words, | | | this will always be a multiple of 32 bytes | +---------------------------------------------------------------------------------------------------------------+ | *Execution control* | +---------------------------------------------------------------------------------------------------------------+ -| create(v:256, p:256, s:256) | create new contract with code mem[p..(p+s)) and send v wei | +| create(v:u256, p:u256, s:u256) | create new contract with code mem[p..(p+s)) and send v wei | | | and return the new address | +---------------------------------------------------------------------------------------------------------------+ -| call(g:256, a:256, v:256, in:256, | call contract at address a with input mem[in..(in+insize)) | -| insize:256, out:256, outsize:256) -> r:256 | providing g gas and v wei and output area | -| | mem[out..(out+outsize)) returning 0 on error (eg. out of gas) | -| | and 1 on success | +| call(g:u256, a:u256, v:u256, in:u256, | call contract at address a with input mem[in..(in+insize)) | +| insize:u256, out:u256, | providing g gas and v wei and output area | +| outsize:u256) | mem[out..(out+outsize)) returning 0 on error (eg. out of gas) | +| -> r:u256 | and 1 on success | +---------------------------------------------------------------------------------------------------------------+ -| callcode(g:256, a:256, v:256, in:256, | identical to `call` but only use the code from a and stay | -| insize:256, out:256, outsize:256) -> r:256 | in the context of the current contract otherwise | +| callcode(g:u256, a:u256, v:u256, in:u256, | identical to ``call`` but only use the code from a | +| insize:u256, out:u256, | and stay in the context of the | +| outsize:u256) -> r:u256 | current contract otherwise | +---------------------------------------------------------------------------------------------------------------+ -| delegatecall(g:256, a:256, in:256, | identical to `callcode` but also keep ``caller`` | -| insize:256, out:256, outsize:256) -> r:256 | and ``callvalue`` | +| delegatecall(g:u256, a:u256, in:u256, | identical to ``callcode``, | +| insize:u256, out:u256, | but also keep ``caller`` | +| outsize:u256) -> r:u256 | and ``callvalue`` | +---------------------------------------------------------------------------------------------------------------+ | stop() | stop execution, identical to return(0,0) | | Perhaps it would make sense retiring this as it equals to return(0,0). It can be an optimisation by the EVM | @@ -300,71 +302,71 @@ The following functions must be available: +---------------------------------------------------------------------------------------------------------------+ | abort() | abort (equals to invalid instruction on EVM) | +---------------------------------------------------------------------------------------------------------------+ -| return(p:256, s:256) | end execution, return data mem[p..(p+s)) | +| return(p:u256, s:u256) | end execution, return data mem[p..(p+s)) | +---------------------------------------------------------------------------------------------------------------+ -| revert(p:256, s:256) | end execution, revert state changes, return data mem[p..(p+s)) | +| revert(p:u256, s:u256) | end execution, revert state changes, return data mem[p..(p+s)) | +---------------------------------------------------------------------------------------------------------------+ -| selfdestruct(a:256) | end execution, destroy current contract and send funds to a | +| selfdestruct(a:u256) | end execution, destroy current contract and send funds to a | +---------------------------------------------------------------------------------------------------------------+ -| log0(p:256, s:256) | log without topics and data mem[p..(p+s)) | +| log0(p:u256, s:u256) | log without topics and data mem[p..(p+s)) | +---------------------------------------------------------------------------------------------------------------+ -| log1(p:256, s:256, t1:256) | log with topic t1 and data mem[p..(p+s)) | +| log1(p:u256, s:u256, t1:u256) | log with topic t1 and data mem[p..(p+s)) | +---------------------------------------------------------------------------------------------------------------+ -| log2(p:256, s:256, t1:256, t2:256) | log with topics t1, t2 and data mem[p..(p+s)) | +| log2(p:u256, s:u256, t1:u256, t2:u256) | log with topics t1, t2 and data mem[p..(p+s)) | +---------------------------------------------------------------------------------------------------------------+ -| log3(p:256, s:256, t1:256, t2:256, | log with topics t, t2, t3 and data mem[p..(p+s)) | -| t3:256) | | +| log3(p:u256, s:u256, t1:u256, t2:u256, | log with topics t, t2, t3 and data mem[p..(p+s)) | +| t3:u256) | | +---------------------------------------------------------------------------------------------------------------+ -| log4(p:256, s:256, t1:256, t2:256, | log with topics t1, t2, t3, t4 and data mem[p..(p+s)) | -| t3:256, t4:256) | | +| log4(p:u256, s:u256, t1:u256, t2:u256, | log with topics t1, t2, t3, t4 and data mem[p..(p+s)) | +| t3:u256, t4:u256) | | +---------------------------------------------------------------------------------------------------------------+ | *State queries* | +---------------------------------------------------------------------------------------------------------------+ -| blockcoinbase() -> address:256 | current mining beneficiary | +| blockcoinbase() -> address:u256 | current mining beneficiary | +---------------------------------------------------------------------------------------------------------------+ -| blockdifficulty() -> difficulty:256 | difficulty of the current block | +| blockdifficulty() -> difficulty:u256 | difficulty of the current block | +---------------------------------------------------------------------------------------------------------------+ -| blockgaslimit() -> limit:256 | block gas limit of the current block | +| blockgaslimit() -> limit:u256 | block gas limit of the current block | +---------------------------------------------------------------------------------------------------------------+ -| blockhash(b:256) -> hash:256 | hash of block nr b - only for last 256 blocks excluding current | +| blockhash(b:u256) -> hash:u256 | hash of block nr b - only for last 256 blocks excluding current | +---------------------------------------------------------------------------------------------------------------+ -| blocknumber() -> block:256 | current block number | +| blocknumber() -> block:u256 | current block number | +---------------------------------------------------------------------------------------------------------------+ -| blocktimestamp() -> timestamp:256 | timestamp of the current block in seconds since the epoch | +| blocktimestamp() -> timestamp:u256 | timestamp of the current block in seconds since the epoch | +---------------------------------------------------------------------------------------------------------------+ -| txorigin() -> address:256 | transaction sender | +| txorigin() -> address:u256 | transaction sender | +---------------------------------------------------------------------------------------------------------------+ -| txgasprice() -> price:256 | gas price of the transaction | +| txgasprice() -> price:u256 | gas price of the transaction | +---------------------------------------------------------------------------------------------------------------+ -| gasleft() -> gas:256 | gas still available to execution | +| gasleft() -> gas:u256 | gas still available to execution | +---------------------------------------------------------------------------------------------------------------+ -| balance(a:256) -> v:256 | wei balance at address a | +| balance(a:u256) -> v:u256 | wei balance at address a | +---------------------------------------------------------------------------------------------------------------+ -| this() -> address:256 | address of the current contract / execution context | +| this() -> address:u256 | address of the current contract / execution context | +---------------------------------------------------------------------------------------------------------------+ -| caller() -> address:256 | call sender (excluding delegatecall) | +| caller() -> address:u256 | call sender (excluding delegatecall) | +---------------------------------------------------------------------------------------------------------------+ -| callvalue() -> v:256 | wei sent together with the current call | +| callvalue() -> v:u256 | wei sent together with the current call | +---------------------------------------------------------------------------------------------------------------+ -| calldataload(p:256) -> v:256 | call data starting from position p (32 bytes) | +| calldataload(p:u256) -> v:u256 | call data starting from position p (32 bytes) | +---------------------------------------------------------------------------------------------------------------+ -| calldatasize() -> v:256 | size of call data in bytes | +| calldatasize() -> v:u256 | size of call data in bytes | +---------------------------------------------------------------------------------------------------------------+ -| calldatacopy(t:256, f:256, s:256) | copy s bytes from calldata at position f to mem at position t | +| calldatacopy(t:u256, f:u256, s:u256) | copy s bytes from calldata at position f to mem at position t | +---------------------------------------------------------------------------------------------------------------+ -| codesize() -> size:256 | size of the code of the current contract / execution context | +| codesize() -> size:u256 | size of the code of the current contract / execution context | +---------------------------------------------------------------------------------------------------------------+ -| codecopy(t:256, f:256, s:256) | copy s bytes from code at position f to mem at position t | +| codecopy(t:u256, f:u256, s:u256) | copy s bytes from code at position f to mem at position t | +---------------------------------------------------------------------------------------------------------------+ -| extcodesize(a:256) -> size:256 | size of the code at address a | +| extcodesize(a:u256) -> size:u256 | size of the code at address a | +---------------------------------------------------------------------------------------------------------------+ -| extcodecopy(a:256, t:256, f:256, s:256) | like codecopy(t, f, s) but take code at address a | +| extcodecopy(a:u256, t:u256, f:u256, s:u256) | like codecopy(t, f, s) but take code at address a | +---------------------------------------------------------------------------------------------------------------+ | *Others* | +---------------------------------------------------------------------------------------------------------------+ -| discard256(unused:256) | discard value | +| discardu256(unused:u256) | discard value | +---------------------------------------------------------------------------------------------------------------+ -| sha3(p:256, s:256) -> v:256 | keccak(mem[p...(p+s))) | +| sha3(p:u256, s:u256) -> v:u256 | keccak(mem[p...(p+s))) | +---------------------------------------------------------------------------------------------------------------+ Backends -- cgit