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)
}
}
)"
// 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 {
switch cmp(x1, y1)
case 0 {
@ -335,6 +338,11 @@ function signextend(x1, x2, x3, x4, y1, y2, y3, y4) -> z1, z2, z3, z4 {
// TODO implement
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 {
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
}
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 {
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 {
// TODO implement
unreachable()
@ -361,8 +389,9 @@ function address() -> z1, z2, z3, z4 {
z1, z2, z3, z4 := mload_internal(0)
}
function balance(x1, x2, x3, x4) -> z1, z2, z3, z4 {
// TODO implement
unreachable()
mstore_address(0, x1, x2, x3, x4)
eth.getExternalBalance(12, 48)
z1, z2, z3, z4 := mload_internal(32)
}
function selfbalance() -> z1, z2, z3, z4 {
// 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) {
eth.callDataCopy(
// scratch - TODO: overflow check
i64.add(u256_to_i32ptr(x1, x2, x3, x4), 64),
to_internal_i32ptr(x1, x2, x3, x4),
u256_to_i32(y1, y2, y3, y4),
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) {
eth.codeCopy(
// scratch - TODO: overflow check
i64.add(u256_to_i32ptr(x1, x2, x3, x4), 64),
to_internal_i32ptr(x1, x2, x3, x4),
u256_to_i32(y1, y2, y3, y4),
u256_to_i32(z1, z2, z3, z4)
)
@ -421,17 +448,22 @@ function gasprice() -> z1, z2, z3, z4 {
eth.getTxGasPrice(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 {
// TODO implement
unreachable()
z4 := extcodesize_internal(x1, x2, x3, x4)
}
function extcodehash(x1, x2, x3, x4) -> z1, z2, z3, z4 {
// TODO: not part of current Ewasm spec
unreachable()
}
function extcodecopy(v1, v2, v3, v4, x1, x2, x3, x4, y1, y2, y3, y4, z1, z2, z3, z4) {
// TODO implement
unreachable()
function extcodecopy(a1, a2, a3, a4, p1, p2, p3, p4, o1, o2, o3, o4, l1, l2, l3, l4) {
mstore_address(0, a1, a2, a3, a4)
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 {
@ -439,20 +471,21 @@ function returndatasize() -> z1, z2, z3, z4 {
}
function returndatacopy(x1, x2, x3, x4, y1, y2, y3, y4, z1, z2, z3, z4) {
eth.returnDataCopy(
// scratch - TODO: overflow check
i64.add(u256_to_i32ptr(x1, x2, x3, x4), 64),
to_internal_i32ptr(x1, x2, x3, x4),
u256_to_i32(y1, y2, y3, y4),
u256_to_i32(z1, z2, z3, z4)
)
}
function blockhash(x1, x2, x3, x4) -> z1, z2, z3, z4 {
// TODO implement
unreachable()
let r := eth.getBlockHash(u256_to_i64(x1, x2, x3, x4), 0)
if i64.eqz(r) {
z1, z2, z3, z4 := mload_internal(0)
}
}
function coinbase() -> z1, z2, z3, z4 {
// TODO implement
unreachable()
eth.getBlockCoinbase(0)
z1, z2, z3, z4 := mload_internal(0)
}
function timestamp() -> z1, z2, z3, z4 {
z4 := eth.getBlockTimestamp()
@ -522,11 +555,7 @@ function restore_temp_mem_64(t1, t2, t3, t4, t5, t6, t7, t8) {
i64.store(54, t8)
}
function mload(x1, x2, x3, x4) -> z1, z2, z3, z4 {
let pos := u256_to_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)
z1, z2, z3, z4 := mload_internal(to_internal_i32ptr(x1, x2, x3, x4))
}
function mload_internal(pos) -> z1, z2, z3, z4 {
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)))
}
function mstore(x1, x2, x3, x4, y1, y2, y3, y4) {
let pos := u256_to_i32ptr(x1, x2, x3, x4)
// 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)
mstore_internal(to_internal_i32ptr(x1, x2, x3, x4), y1, y2, y3, y4)
}
function mstore_internal(pos, y1, y2, y3, y4) {
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, 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) {
// TODO implement
unreachable()
@ -578,47 +607,84 @@ function gas() -> z1, z2, z3, z4 {
}
function log0(p1, p2, p3, p4, s1, s2, s3, s4) {
// TODO implement
unreachable()
eth.log(
to_internal_i32ptr(p1, p2, p3, p4),
u256_to_i32(s1, s2, s3, s4),
0, 0, 0, 0, 0
)
}
function log1(
p1, p2, p3, p4, s1, s2, s3, s4,
t11, t12, t13, t14
t1_1, t1_2, t1_3, t1_4
) {
// TODO implement
unreachable()
eth.log(
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(
p1, p2, p3, p4, s1, s2, s3, s4,
t11, t12, t13, t14,
t21, t22, t23, t24
t1_1, t1_2, t1_3, t1_4,
t2_1, t2_2, t2_3, t2_4
) {
// TODO implement
unreachable()
eth.log(
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(
p1, p2, p3, p4, s1, s2, s3, s4,
t11, t12, t13, t14,
t21, t22, t23, t24,
t31, t32, t33, t34
t1_1, t1_2, t1_3, t1_4,
t2_1, t2_2, t2_3, t2_4,
t3_1, t3_2, t3_3, t3_4
) {
// TODO implement
unreachable()
eth.log(
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(
p1, p2, p3, p4, s1, s2, s3, s4,
t11, t12, t13, t14,
t21, t22, t23, t24,
t31, t32, t33, t34,
t41, t42, t43, t44,
t1_1, t1_2, t1_3, t1_4,
t2_1, t2_2, t2_3, t2_4,
t3_1, t3_2, t3_3, t3_4,
t4_1, t4_2, t4_3, t4_4,
) {
// TODO implement
unreachable()
eth.log(
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 {
// TODO implement
unreachable()
function create(
x1, x2, x3, x4,
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(
a1, a2, a3, a4,
@ -629,8 +695,13 @@ function call(
f1, f2, f3, f4,
g1, g2, g3, g4
) -> x1, x2, x3, x4 {
// TODO implement
unreachable()
let g := u256_to_i64(a1, a2, a3, a4)
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(
a1, a2, a3, a4,
@ -641,8 +712,18 @@ function callcode(
f1, f2, f3, f4,
g1, g2, g3, g4
) -> x1, x2, x3, x4 {
// TODO implement
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.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(
a1, a2, a3, a4,
@ -652,8 +733,14 @@ function delegatecall(
e1, e2, e3, e4,
f1, f2, f3, f4
) -> x1, x2, x3, x4 {
// TODO implement
unreachable()
mstore_address(0, b1, b2, b3, b4)
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(
a1, a2, a3, a4,
@ -663,8 +750,14 @@ function staticcall(
e1, e2, e3, e4,
f1, f2, f3, f4
) -> x1, x2, x3, x4 {
// TODO implement
unreachable()
mstore_address(0, b1, b2, b3, b4)
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(
a1, a2, a3, a4,
@ -676,22 +769,20 @@ function create2(
unreachable()
}
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.
eth.selfDestruct(12)
}
function return(x1, x2, x3, x4, y1, y2, y3, y4) {
eth.finish(
// scratch - TODO: overflow check
i64.add(u256_to_i32ptr(x1, x2, x3, x4), 64),
to_internal_i32ptr(x1, x2, x3, x4),
u256_to_i32(y1, y2, y3, y4)
)
}
function revert(x1, x2, x3, x4, y1, y2, y3, y4) {
eth.revert(
// scratch - TODO: overflow check
i64.add(u256_to_i32ptr(x1, x2, x3, x4), 64),
to_internal_i32ptr(x1, x2, x3, x4),
u256_to_i32(y1, y2, y3, y4)
)
}
@ -768,4 +859,3 @@ void EVMToEwasmTranslator::parsePolyfill()
for (auto const& statement: m_polyfill->statements)
m_polyfillFunctions.insert(std::get<FunctionDefinition>(statement).name);
}

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

@ -7,23 +7,29 @@
(func $main
(local $_1 i64)
(local $_2 i64)
(local $p i64)
(local $r i64)
(local $hi i64)
(local $y 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 $_2 (i64.add (call $u256_to_i32 (local.get $_1) (local.get $_1) (local.get $_1) (i64.const 64)) (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 $y (i64.or (local.get $hi) (call $endian_swap_32 (i64.shr_u (local.get $_1) (i64.const 32)))))
(i64.store (i32.wrap_i64 (local.get $_2)) (local.get $y))
(i64.store (i32.wrap_i64 (i64.add (local.get $_2) (i64.const 8))) (local.get $y))
(i64.store (i32.wrap_i64 (i64.add (local.get $_2) (i64.const 16))) (local.get $y))
(local.set $hi_1 (i64.shl (call $endian_swap_32 (i64.const 128)) (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)))))
(local.set $_3 (datasize \"C_2_deployed\"))
(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))))
(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 $p (call $u256_to_i32 (local.get $_1) (local.get $_1) (local.get $_1) (i64.const 64)))
(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.set $hi (i64.shl (call $endian_swap_16 (local.get $_1)) (i64.const 16)))
(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 $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 (local.get $r)) (local.get $y))
(i64.store (i32.wrap_i64 (i64.add (local.get $r) (i64.const 8))) (local.get $y))
(i64.store (i32.wrap_i64 (i64.add (local.get $r) (i64.const 16))) (local.get $y))
(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
@ -41,6 +47,21 @@
(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
(param $x i64)
(result i64)

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

@ -4,7 +4,9 @@
}
// ----
// Trace:
// INVALID()
// Memory dump:
// 0: 0000000000000000000000000000000011111111000000000000000000000000
// 0: 0000000000000000000000000000000000000000000000000000000000000001
// 20: 0000000000000000000000000000000000000000000000000000000022222222
// 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:
// INVALID()
// Memory dump:
// 20: 00000000000000000000000000000000000000000000000000000000aaaaa9a9
// Storage dump:
// 0000000000000000000000000000000000000000000000000000000000000000: 00000000000000000000000000000000000000000000000000000000aaaaa9a9

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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