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

Merge pull request #8049 from imapp-pl/polyfill-part-1

Browse Source 
Ewasm polyfill getter functions
This commit is contained in:
chriseth 2020-01-08 10:26:29 +01:00 committed by GitHub
commit 06a7c49729
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 224 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

220
libyul/backends/wasm/EVMToEwasmTranslator.cpp
View File

@ -214,7 +214,10 @@ function cmp(a, b) -> r {
r := i64.ne(a, b) r := i64.ne(a, b)
} }
} }
)"
// Split long string to make it compilable on msvc
// https://docs.microsoft.com/en-us/cpp/error-messages/compiler-errors-1/compiler-error-c2026?view=vs-2019
R"(
function lt(x1, x2, x3, x4, y1, y2, y3, y4) -> z1, z2, z3, z4 { function lt(x1, x2, x3, x4, y1, y2, y3, y4) -> z1, z2, z3, z4 {
switch cmp(x1, y1) switch cmp(x1, y1)
case 0 { case 0 {
@ -335,6 +338,11 @@ function signextend(x1, x2, x3, x4, y1, y2, y3, y4) -> z1, z2, z3, z4 {
// TODO implement // TODO implement
unreachable() unreachable()
} }
function u256_to_u128(x1, x2, x3, x4) -> v1, v2 {
if i64.ne(0, i64.or(x1, x2)) { invalid() }
v2 := x4
v1 := x3
}
function u256_to_i64(x1, x2, x3, x4) -> v { function u256_to_i64(x1, x2, x3, x4) -> v {
if i64.ne(0, i64.or(i64.or(x1, x2), x3)) { invalid() } if i64.ne(0, i64.or(i64.or(x1, x2), x3)) { invalid() }
@ -347,10 +355,30 @@ function u256_to_i32(x1, x2, x3, x4) -> v {
v := x4 v := x4
} }
function u256_to_byte(x1, x2, x3, x4) -> v {
if i64.ne(0, i64.or(i64.or(x1, x2), x3)) { invalid() }
if i64.gt_u(x4, 255) { invalid() }
v := x4
}
function u256_to_i32ptr(x1, x2, x3, x4) -> v { function u256_to_i32ptr(x1, x2, x3, x4) -> v {
v := u256_to_i32(x1, x2, x3, x4) v := u256_to_i32(x1, x2, x3, x4)
} }
function to_internal_i32ptr(x1, x2, x3, x4) -> r {
let p := u256_to_i32ptr(x1, x2, x3, x4)
r := i64.add(p, 64)
if i64.lt_u(r, p) { invalid() }
}
function u256_to_address(x1, x2, x3, x4) -> r1, r2, r3 {
if i64.ne(0, x1) { invalid() }
if i64.ne(0, i64.shr_u(x2, 32)) { invalid() }
r1 := x2
r2 := x3
r3 := x4
}
function keccak256(x1, x2, x3, x4, y1, y2, y3, y4) -> z1, z2, z3, z4 { function keccak256(x1, x2, x3, x4, y1, y2, y3, y4) -> z1, z2, z3, z4 {
// TODO implement // TODO implement
unreachable() unreachable()
@ -361,8 +389,9 @@ function address() -> z1, z2, z3, z4 {
z1, z2, z3, z4 := mload_internal(0) z1, z2, z3, z4 := mload_internal(0)
} }
function balance(x1, x2, x3, x4) -> z1, z2, z3, z4 { function balance(x1, x2, x3, x4) -> z1, z2, z3, z4 {
// TODO implement mstore_address(0, x1, x2, x3, x4)
unreachable() eth.getExternalBalance(12, 48)
z1, z2, z3, z4 := mload_internal(32)
} }
function selfbalance() -> z1, z2, z3, z4 { function selfbalance() -> z1, z2, z3, z4 {
// TODO: not part of current Ewasm spec // TODO: not part of current Ewasm spec
@ -393,8 +422,7 @@ function calldatasize() -> z1, z2, z3, z4 {
} }
function calldatacopy(x1, x2, x3, x4, y1, y2, y3, y4, z1, z2, z3, z4) { function calldatacopy(x1, x2, x3, x4, y1, y2, y3, y4, z1, z2, z3, z4) {
eth.callDataCopy( eth.callDataCopy(
// scratch - TODO: overflow check to_internal_i32ptr(x1, x2, x3, x4),
i64.add(u256_to_i32ptr(x1, x2, x3, x4), 64),
u256_to_i32(y1, y2, y3, y4), u256_to_i32(y1, y2, y3, y4),
u256_to_i32(z1, z2, z3, z4) u256_to_i32(z1, z2, z3, z4)
) )
@ -406,8 +434,7 @@ function codesize() -> z1, z2, z3, z4 {
} }
function codecopy(x1, x2, x3, x4, y1, y2, y3, y4, z1, z2, z3, z4) { function codecopy(x1, x2, x3, x4, y1, y2, y3, y4, z1, z2, z3, z4) {
eth.codeCopy( eth.codeCopy(
// scratch - TODO: overflow check to_internal_i32ptr(x1, x2, x3, x4),
i64.add(u256_to_i32ptr(x1, x2, x3, x4), 64),
u256_to_i32(y1, y2, y3, y4), u256_to_i32(y1, y2, y3, y4),
u256_to_i32(z1, z2, z3, z4) u256_to_i32(z1, z2, z3, z4)
) )
@ -421,17 +448,22 @@ function gasprice() -> z1, z2, z3, z4 {
eth.getTxGasPrice(0) eth.getTxGasPrice(0)
z1, z2, z3, z4 := mload_internal(0) z1, z2, z3, z4 := mload_internal(0)
} }
function extcodesize_internal(x1, x2, x3, x4) -> r {
mstore_address(0, x1, x2, x3, x4)
r := eth.getExternalCodeSize(12)
}
function extcodesize(x1, x2, x3, x4) -> z1, z2, z3, z4 { function extcodesize(x1, x2, x3, x4) -> z1, z2, z3, z4 {
// TODO implement z4 := extcodesize_internal(x1, x2, x3, x4)
unreachable()
} }
function extcodehash(x1, x2, x3, x4) -> z1, z2, z3, z4 { function extcodehash(x1, x2, x3, x4) -> z1, z2, z3, z4 {
// TODO: not part of current Ewasm spec // TODO: not part of current Ewasm spec
unreachable() unreachable()
} }
function extcodecopy(v1, v2, v3, v4, x1, x2, x3, x4, y1, y2, y3, y4, z1, z2, z3, z4) { function extcodecopy(a1, a2, a3, a4, p1, p2, p3, p4, o1, o2, o3, o4, l1, l2, l3, l4) {
// TODO implement mstore_address(0, a1, a2, a3, a4)
unreachable() let codeOffset := u256_to_i32(o1, o2, o3, o4)
let codeLength := u256_to_i32(l1, l2, l3, l4)
eth.externalCodeCopy(12, to_internal_i32ptr(p1, p2, p3, p4), codeOffset, codeLength)
} }
function returndatasize() -> z1, z2, z3, z4 { function returndatasize() -> z1, z2, z3, z4 {
@ -439,20 +471,21 @@ function returndatasize() -> z1, z2, z3, z4 {
} }
function returndatacopy(x1, x2, x3, x4, y1, y2, y3, y4, z1, z2, z3, z4) { function returndatacopy(x1, x2, x3, x4, y1, y2, y3, y4, z1, z2, z3, z4) {
eth.returnDataCopy( eth.returnDataCopy(
// scratch - TODO: overflow check to_internal_i32ptr(x1, x2, x3, x4),
i64.add(u256_to_i32ptr(x1, x2, x3, x4), 64),
u256_to_i32(y1, y2, y3, y4), u256_to_i32(y1, y2, y3, y4),
u256_to_i32(z1, z2, z3, z4) u256_to_i32(z1, z2, z3, z4)
) )
} }
function blockhash(x1, x2, x3, x4) -> z1, z2, z3, z4 { function blockhash(x1, x2, x3, x4) -> z1, z2, z3, z4 {
// TODO implement let r := eth.getBlockHash(u256_to_i64(x1, x2, x3, x4), 0)
unreachable() if i64.eqz(r) {
z1, z2, z3, z4 := mload_internal(0)
}
} }
function coinbase() -> z1, z2, z3, z4 { function coinbase() -> z1, z2, z3, z4 {
// TODO implement eth.getBlockCoinbase(0)
unreachable() z1, z2, z3, z4 := mload_internal(0)
} }
function timestamp() -> z1, z2, z3, z4 { function timestamp() -> z1, z2, z3, z4 {
z4 := eth.getBlockTimestamp() z4 := eth.getBlockTimestamp()
@ -522,11 +555,7 @@ function restore_temp_mem_64(t1, t2, t3, t4, t5, t6, t7, t8) {
i64.store(54, t8) i64.store(54, t8)
} }
function mload(x1, x2, x3, x4) -> z1, z2, z3, z4 { function mload(x1, x2, x3, x4) -> z1, z2, z3, z4 {
let pos := u256_to_i32ptr(x1, x2, x3, x4) z1, z2, z3, z4 := mload_internal(to_internal_i32ptr(x1, x2, x3, x4))
// Make room for the scratch space
// TODO do we need to check for overflow?
pos := i64.add(pos, 64)
z1, z2, z3, z4 := mload_internal(pos)
} }
function mload_internal(pos) -> z1, z2, z3, z4 { function mload_internal(pos) -> z1, z2, z3, z4 {
z1 := endian_swap(i64.load(pos)) z1 := endian_swap(i64.load(pos))
@ -535,11 +564,7 @@ function mload_internal(pos) -> z1, z2, z3, z4 {
z4 := endian_swap(i64.load(i64.add(pos, 24))) z4 := endian_swap(i64.load(i64.add(pos, 24)))
} }
function mstore(x1, x2, x3, x4, y1, y2, y3, y4) { function mstore(x1, x2, x3, x4, y1, y2, y3, y4) {
let pos := u256_to_i32ptr(x1, x2, x3, x4) mstore_internal(to_internal_i32ptr(x1, x2, x3, x4), y1, y2, y3, y4)
// Make room for the scratch space
// TODO do we need to check for overflow?
pos := i64.add(pos, 64)
mstore_internal(pos, y1, y2, y3, y4)
} }
function mstore_internal(pos, y1, y2, y3, y4) { function mstore_internal(pos, y1, y2, y3, y4) {
i64.store(pos, endian_swap(y1)) i64.store(pos, endian_swap(y1))
@ -547,6 +572,10 @@ function mstore_internal(pos, y1, y2, y3, y4) {
i64.store(i64.add(pos, 16), endian_swap(y3)) i64.store(i64.add(pos, 16), endian_swap(y3))
i64.store(i64.add(pos, 24), endian_swap(y4)) i64.store(i64.add(pos, 24), endian_swap(y4))
} }
function mstore_address(pos, a1, a2, a3, a4) {
a1, a2, a3 := u256_to_address(a1, a2, a3, a4)
mstore_internal(pos, 0, a1, a2, a3)
}
function mstore8(x1, x2, x3, x4, y1, y2, y3, y4) { function mstore8(x1, x2, x3, x4, y1, y2, y3, y4) {
// TODO implement // TODO implement
unreachable() unreachable()
@ -578,47 +607,84 @@ function gas() -> z1, z2, z3, z4 {
} }
function log0(p1, p2, p3, p4, s1, s2, s3, s4) { function log0(p1, p2, p3, p4, s1, s2, s3, s4) {
// TODO implement eth.log(
unreachable() to_internal_i32ptr(p1, p2, p3, p4),
u256_to_i32(s1, s2, s3, s4),
0, 0, 0, 0, 0
)
} }
function log1( function log1(
p1, p2, p3, p4, s1, s2, s3, s4, p1, p2, p3, p4, s1, s2, s3, s4,
t11, t12, t13, t14 t1_1, t1_2, t1_3, t1_4
) { ) {
// TODO implement eth.log(
unreachable() to_internal_i32ptr(p1, p2, p3, p4),
u256_to_i32(s1, s2, s3, s4),
1,
to_internal_i32ptr(t1_1, t1_2, t1_3, t1_4),
0, 0, 0
)
} }
function log2( function log2(
p1, p2, p3, p4, s1, s2, s3, s4, p1, p2, p3, p4, s1, s2, s3, s4,
t11, t12, t13, t14, t1_1, t1_2, t1_3, t1_4,
t21, t22, t23, t24 t2_1, t2_2, t2_3, t2_4
) { ) {
// TODO implement eth.log(
unreachable() to_internal_i32ptr(p1, p2, p3, p4),
u256_to_i32(s1, s2, s3, s4),
2,
to_internal_i32ptr(t1_1, t1_2, t1_3, t1_4),
to_internal_i32ptr(t2_1, t2_2, t2_3, t2_4),
0, 0
)
} }
function log3( function log3(
p1, p2, p3, p4, s1, s2, s3, s4, p1, p2, p3, p4, s1, s2, s3, s4,
t11, t12, t13, t14, t1_1, t1_2, t1_3, t1_4,
t21, t22, t23, t24, t2_1, t2_2, t2_3, t2_4,
t31, t32, t33, t34 t3_1, t3_2, t3_3, t3_4
) { ) {
// TODO implement eth.log(
unreachable() to_internal_i32ptr(p1, p2, p3, p4),
u256_to_i32(s1, s2, s3, s4),
3,
to_internal_i32ptr(t1_1, t1_2, t1_3, t1_4),
to_internal_i32ptr(t2_1, t2_2, t2_3, t2_4),
to_internal_i32ptr(t3_1, t3_2, t3_3, t3_4),
0
)
} }
function log4( function log4(
p1, p2, p3, p4, s1, s2, s3, s4, p1, p2, p3, p4, s1, s2, s3, s4,
t11, t12, t13, t14, t1_1, t1_2, t1_3, t1_4,
t21, t22, t23, t24, t2_1, t2_2, t2_3, t2_4,
t31, t32, t33, t34, t3_1, t3_2, t3_3, t3_4,
t41, t42, t43, t44, t4_1, t4_2, t4_3, t4_4,
) { ) {
// TODO implement eth.log(
unreachable() to_internal_i32ptr(p1, p2, p3, p4),
u256_to_i32(s1, s2, s3, s4),
4,
to_internal_i32ptr(t1_1, t1_2, t1_3, t1_4),
to_internal_i32ptr(t2_1, t2_2, t2_3, t2_4),
to_internal_i32ptr(t3_1, t3_2, t3_3, t3_4),
to_internal_i32ptr(t4_1, t4_2, t4_3, t4_4)
)
} }
function create(x1, x2, x3, x4, y1, y2, y3, y4, z1, z2, z3, z4) -> a1, a2, a3, a4 { function create(
// TODO implement x1, x2, x3, x4,
unreachable() y1, y2, y3, y4,
z1, z2, z3, z4
) -> a1, a2, a3, a4 {
let v1, v2 := u256_to_u128(x1, x2, x3, x4)
mstore_internal(0, 0, 0, v1, v2)
let r := eth.create(0, to_internal_i32ptr(y1, y2, y3, y4), u256_to_i32(z1, z2, z3, z4), 32)
if i64.eqz(r) {
a1, a2, a3, a4 := mload_internal(32)
}
} }
function call( function call(
a1, a2, a3, a4, a1, a2, a3, a4,
@ -629,8 +695,13 @@ function call(
f1, f2, f3, f4, f1, f2, f3, f4,
g1, g2, g3, g4 g1, g2, g3, g4
) -> x1, x2, x3, x4 { ) -> x1, x2, x3, x4 {
// TODO implement let g := u256_to_i64(a1, a2, a3, a4)
unreachable() mstore_address(0, b1, b2, b3, b4)
let v1, v2 := u256_to_u128(c1, c2, c3, c4)
mstore_internal(32, 0, 0, v1, v2)
x4 := eth.call(g, 12, 32, to_internal_i32ptr(d1, d2, d3, d4), u256_to_i32(e1, e2, e3, e4))
} }
function callcode( function callcode(
a1, a2, a3, a4, a1, a2, a3, a4,
@ -641,8 +712,18 @@ function callcode(
f1, f2, f3, f4, f1, f2, f3, f4,
g1, g2, g3, g4 g1, g2, g3, g4
) -> x1, x2, x3, x4 { ) -> x1, x2, x3, x4 {
// TODO implement mstore_address(0, b1, b2, b3, b4)
unreachable()
let v1, v2 := u256_to_u128(c1, c2, c3, c4)
mstore_internal(32, 0, 0, v1, v2)
x4 := eth.callCode(
u256_to_i64(a1, a2, a3, a4),
12,
32,
to_internal_i32ptr(d1, d2, d3, d4),
u256_to_i32(e1, e2, e3, e4)
)
} }
function delegatecall( function delegatecall(
a1, a2, a3, a4, a1, a2, a3, a4,
@ -652,8 +733,14 @@ function delegatecall(
e1, e2, e3, e4, e1, e2, e3, e4,
f1, f2, f3, f4 f1, f2, f3, f4
) -> x1, x2, x3, x4 { ) -> x1, x2, x3, x4 {
// TODO implement mstore_address(0, b1, b2, b3, b4)
unreachable()
x4 := eth.callDelegate(
u256_to_i64(a1, a2, a3, a4),
12,
to_internal_i32ptr(c1, c2, c3, c4),
u256_to_i32(d1, d2, d3, d4)
)
} }
function staticcall( function staticcall(
a1, a2, a3, a4, a1, a2, a3, a4,
@ -663,8 +750,14 @@ function staticcall(
e1, e2, e3, e4, e1, e2, e3, e4,
f1, f2, f3, f4 f1, f2, f3, f4
) -> x1, x2, x3, x4 { ) -> x1, x2, x3, x4 {
// TODO implement mstore_address(0, b1, b2, b3, b4)
unreachable()
x4 := eth.callStatic(
u256_to_i64(a1, a2, a3, a4),
12,
to_internal_i32ptr(c1, c2, c3, c4),
u256_to_i32(d1, d2, d3, d4)
)
} }
function create2( function create2(
a1, a2, a3, a4, a1, a2, a3, a4,
@ -676,22 +769,20 @@ function create2(
unreachable() unreachable()
} }
function selfdestruct(a1, a2, a3, a4) { function selfdestruct(a1, a2, a3, a4) {
mstore(0, 0, 0, 0, a1, a2, a3, a4) mstore_address(0, a1, a2, a3, a4)
// In EVM, addresses are padded to 32 bytes, so discard the first 12. // In EVM, addresses are padded to 32 bytes, so discard the first 12.
eth.selfDestruct(12) eth.selfDestruct(12)
} }
function return(x1, x2, x3, x4, y1, y2, y3, y4) { function return(x1, x2, x3, x4, y1, y2, y3, y4) {
eth.finish( eth.finish(
// scratch - TODO: overflow check to_internal_i32ptr(x1, x2, x3, x4),
i64.add(u256_to_i32ptr(x1, x2, x3, x4), 64),
u256_to_i32(y1, y2, y3, y4) u256_to_i32(y1, y2, y3, y4)
) )
} }
function revert(x1, x2, x3, x4, y1, y2, y3, y4) { function revert(x1, x2, x3, x4, y1, y2, y3, y4) {
eth.revert( eth.revert(
// scratch - TODO: overflow check to_internal_i32ptr(x1, x2, x3, x4),
i64.add(u256_to_i32ptr(x1, x2, x3, x4), 64),
u256_to_i32(y1, y2, y3, y4) u256_to_i32(y1, y2, y3, y4)
) )
} }
@ -768,4 +859,3 @@ void EVMToEwasmTranslator::parsePolyfill()
for (auto const& statement: m_polyfill->statements) for (auto const& statement: m_polyfill->statements)
m_polyfillFunctions.insert(std::get<FunctionDefinition>(statement).name); m_polyfillFunctions.insert(std::get<FunctionDefinition>(statement).name);
} }

49
test/cmdlineTests/standard_eWasm_requested/output.json
View File

@ -7,23 +7,29 @@
(func $main (func $main
(local $_1 i64) (local $_1 i64)
(local $_2 i64) (local $p i64)
(local $r i64)
(local $hi i64) (local $hi i64)
(local $y i64)
(local $hi_1 i64) (local $hi_1 i64)
(local $_3 i64) (local $y i64)
(local $hi_2 i64)
(local $_2 i64)
(local.set $_1 (i64.const 0)) (local.set $_1 (i64.const 0))
(local.set $_2 (i64.add (call $u256_to_i32 (local.get $_1) (local.get $_1) (local.get $_1) (i64.const 64)) (i64.const 64))) (local.set $p (call $u256_to_i32 (local.get $_1) (local.get $_1) (local.get $_1) (i64.const 64)))
(local.set $hi (i64.shl (i64.or (i64.shl (i64.or (i64.and (i64.shl (local.get $_1) (i64.const 8)) (i64.const 65280)) (i64.and (i64.shr_u (local.get $_1) (i64.const 8)) (i64.const 255))) (i64.const 16)) (call $endian_swap_16 (i64.shr_u (local.get $_1) (i64.const 16)))) (i64.const 32))) (local.set $r (i64.add (local.get $p) (i64.const 64)))
(local.set $y (i64.or (local.get $hi) (call $endian_swap_32 (i64.shr_u (local.get $_1) (i64.const 32))))) (if (i64.ne (i64.extend_i32_u (i64.lt_u (local.get $r) (local.get $p))) (i64.const 0)) (then
(i64.store (i32.wrap_i64 (local.get $_2)) (local.get $y)) (unreachable)))
(i64.store (i32.wrap_i64 (i64.add (local.get $_2) (i64.const 8))) (local.get $y)) (local.set $hi (i64.shl (call $endian_swap_16 (local.get $_1)) (i64.const 16)))
(i64.store (i32.wrap_i64 (i64.add (local.get $_2) (i64.const 16))) (local.get $y)) (local.set $hi_1 (i64.shl (i64.or (local.get $hi) (call $endian_swap_16 (i64.shr_u (local.get $_1) (i64.const 16)))) (i64.const 32)))
(local.set $hi_1 (i64.shl (call $endian_swap_32 (i64.const 128)) (i64.const 32))) (local.set $y (i64.or (local.get $hi_1) (call $endian_swap_32 (i64.shr_u (local.get $_1) (i64.const 32)))))
(i64.store (i32.wrap_i64 (i64.add (local.get $_2) (i64.const 24))) (i64.or (local.get $hi_1) (call $endian_swap_32 (i64.shr_u (i64.const 128) (i64.const 32))))) (i64.store (i32.wrap_i64 (local.get $r)) (local.get $y))
(local.set $_3 (datasize \"C_2_deployed\")) (i64.store (i32.wrap_i64 (i64.add (local.get $r) (i64.const 8))) (local.get $y))
(call $eth.codeCopy (i32.wrap_i64 (i64.add (call $u256_to_i32 (local.get $_1) (local.get $_1) (local.get $_1) (local.get $_1)) (i64.const 64))) (i32.wrap_i64 (call $u256_to_i32 (local.get $_1) (local.get $_1) (local.get $_1) (dataoffset \"C_2_deployed\"))) (i32.wrap_i64 (call $u256_to_i32 (local.get $_1) (local.get $_1) (local.get $_1) (local.get $_3)))) (i64.store (i32.wrap_i64 (i64.add (local.get $r) (i64.const 16))) (local.get $y))
(call $eth.finish (i32.wrap_i64 (i64.add (call $u256_to_i32 (local.get $_1) (local.get $_1) (local.get $_1) (local.get $_1)) (i64.const 64))) (i32.wrap_i64 (call $u256_to_i32 (local.get $_1) (local.get $_1) (local.get $_1) (local.get $_3)))) (local.set $hi_2 (i64.shl (call $endian_swap_32 (i64.const 128)) (i64.const 32)))
(i64.store (i32.wrap_i64 (i64.add (local.get $r) (i64.const 24))) (i64.or (local.get $hi_2) (call $endian_swap_32 (i64.shr_u (i64.const 128) (i64.const 32)))))
(local.set $_2 (datasize \"C_2_deployed\"))
(call $eth.codeCopy (i32.wrap_i64 (call $to_internal_i32ptr (local.get $_1) (local.get $_1) (local.get $_1) (local.get $_1))) (i32.wrap_i64 (call $u256_to_i32 (local.get $_1) (local.get $_1) (local.get $_1) (dataoffset \"C_2_deployed\"))) (i32.wrap_i64 (call $u256_to_i32 (local.get $_1) (local.get $_1) (local.get $_1) (local.get $_2))))
(call $eth.finish (i32.wrap_i64 (call $to_internal_i32ptr (local.get $_1) (local.get $_1) (local.get $_1) (local.get $_1))) (i32.wrap_i64 (call $u256_to_i32 (local.get $_1) (local.get $_1) (local.get $_1) (local.get $_2))))
) )
(func $u256_to_i32 (func $u256_to_i32
@ -41,6 +47,21 @@
(local.get $v) (local.get $v)
) )
(func $to_internal_i32ptr
(param $x1 i64)
(param $x2 i64)
(param $x3 i64)
(param $x4 i64)
(result i64)
(local $r i64)
(local $p i64)
(local.set $p (call $u256_to_i32 (local.get $x1) (local.get $x2) (local.get $x3) (local.get $x4)))
(local.set $r (i64.add (local.get $p) (i64.const 64)))
(if (i64.ne (i64.extend_i32_u (i64.lt_u (local.get $r) (local.get $p))) (i64.const 0)) (then
(unreachable)))
(local.get $r)
)
(func $endian_swap_16 (func $endian_swap_16
(param $x i64) (param $x i64)
(result i64) (result i64)

6
test/libyul/ewasmTranslationTests/balance.yul
View File

@ -4,7 +4,9 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID()
// Memory dump: // Memory dump:
// 0: 0000000000000000000000000000000011111111000000000000000000000000 // 0: 0000000000000000000000000000000000000000000000000000000000000001
// 20: 0000000000000000000000000000000000000000000000000000000022222222
// Storage dump: // Storage dump:
// 0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000022222222
// 0000000000000000000000000000000000000000000000000000000000000001: 0000000000000000000000000000000000000000000000000000000022222222

5
test/libyul/ewasmTranslationTests/blockhash.yul
View File

@ -1,8 +1,9 @@
{ {
sstore(0, blockhash(1)) sstore(0, blockhash(1023))
} }
// ---- // ----
// Trace: // Trace:
// INVALID()
// Memory dump: // Memory dump:
// 20: 00000000000000000000000000000000000000000000000000000000aaaaa9a9
// Storage dump: // Storage dump:
// 0000000000000000000000000000000000000000000000000000000000000000: 00000000000000000000000000000000000000000000000000000000aaaaa9a9

3
test/libyul/ewasmTranslationTests/coinbase.yul
View File

@ -3,6 +3,7 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID()
// Memory dump: // Memory dump:
// 20: 0000000000000000000000000000000077777777000000000000000000000000
// Storage dump: // Storage dump:
// 0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000077777777000000000000000000000000

5
test/libyul/ewasmTranslationTests/extcodecopy.yul
View File

@ -4,7 +4,8 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID()
// Memory dump: // Memory dump:
// 0: 0000000000000000000000000000000011111111000000000000000000000000 // 20: 636f6465636f6465636f6465636f6465636f6465000000000000000000000000
// 140: 636f6465636f6465636f6465636f6465636f6465000000000000000000000000
// Storage dump: // Storage dump:
// 0000000000000000000000000000000000000000000000000000000000000000: 636f6465636f6465636f6465636f6465636f6465000000000000000000000000

4
test/libyul/ewasmTranslationTests/extcodesize.yul
View File

@ -3,7 +3,7 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID()
// Memory dump: // Memory dump:
// 0: 0000000000000000000000000000000011111111000000000000000000000000 // 20: 000000000000000000000000000000000000000000000000000000000000077b
// Storage dump: // Storage dump:
// 0000000000000000000000000000000000000000000000000000000000000000: 000000000000000000000000000000000000000000000000000000000000077b

2
test/libyul/ewasmTranslationTests/log0.yul
View File

@ -3,6 +3,6 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID() // LOG0()
// Memory dump: // Memory dump:
// Storage dump: // Storage dump:

2
test/libyul/ewasmTranslationTests/log1.yul
View File

@ -3,6 +3,6 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID() // LOG1()
// Memory dump: // Memory dump:
// Storage dump: // Storage dump:

2
test/libyul/ewasmTranslationTests/log2.yul
View File

@ -3,6 +3,6 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID() // LOG2()
// Memory dump: // Memory dump:
// Storage dump: // Storage dump:

2
test/libyul/ewasmTranslationTests/log3.yul
View File

@ -3,6 +3,6 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID() // LOG3()
// Memory dump: // Memory dump:
// Storage dump: // Storage dump:

2
test/libyul/ewasmTranslationTests/log4.yul
View File

@ -3,6 +3,6 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID() // LOG4()
// Memory dump: // Memory dump:
// Storage dump: // Storage dump:

4
test/libyul/ewasmTranslationTests/selfdestruct.yul
View File

@ -1,10 +1,10 @@
{ {
selfdestruct(not(0)) selfdestruct(0xffffffffffffffffffffffffffffffffffffffff)
invalid() invalid()
} }
// ---- // ----
// Trace: // Trace:
// SELFDESTRUCT() // SELFDESTRUCT()
// Memory dump: // Memory dump:
// 40: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // 0: 000000000000000000000000ffffffffffffffffffffffffffffffffffffffff
// Storage dump: // Storage dump:

5
test/libyul/ewasmTranslationTests/smoke_call.yul
View File

@ -3,7 +3,8 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID() // CALL()
// Memory dump: // Memory dump:
// 0: 0000000000000000000000000000000011111111000000000000000000000000 // 20: 0000000000000000000000000000000000000000000000000000000000000001
// Storage dump: // Storage dump:
// 0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000001

5
test/libyul/ewasmTranslationTests/smoke_callcode.yul
View File

@ -3,7 +3,8 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID() // CALLCODE()
// Memory dump: // Memory dump:
// 0: 0000000000000000000000000000000011111111000000000000000000000000 // 20: 0000000000000000000000000000000000000000000000000000000000000001
// Storage dump: // Storage dump:
// 0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000001

2
test/libyul/ewasmTranslationTests/smoke_create.yul
View File

@ -5,7 +5,7 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID() // CREATE()
// Memory dump: // Memory dump:
// 40: 636f6465636f6465636f6465636f6465636f6465000000000000000000000000 // 40: 636f6465636f6465636f6465636f6465636f6465000000000000000000000000
// Storage dump: // Storage dump:

5
test/libyul/ewasmTranslationTests/smoke_delegatecall.yul
View File

@ -3,7 +3,8 @@
} }
// ---- // ----
// Trace: // Trace:
// INVALID() // DELEGATECALL()
// Memory dump: // Memory dump:
// 0: 0000000000000000000000000000000011111111000000000000000000000000 // 20: 0000000000000000000000000000000000000000000000000000000000000001
// Storage dump: // Storage dump:
// 0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000001

5
test/libyul/ewasmTranslationTests/smoke_staticcall.yul
View File

@ -5,7 +5,8 @@
// EVMVersion: >=byzantium // EVMVersion: >=byzantium
// ---- // ----
// Trace: // Trace:
// INVALID() // STATICCALL()
// Memory dump: // Memory dump:
// 0: 0000000000000000000000000000000011111111000000000000000000000000 // 20: 0000000000000000000000000000000000000000000000000000000000000001
// Storage dump: // Storage dump:
// 0000000000000000000000000000000000000000000000000000000000000000: 0000000000000000000000000000000000000000000000000000000000000001