solang 0.2.1

Solang Solidity Compiler
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

// RUN: --target substrate --emit cfg
contract deadstorage {
    int a;

    // simple test. Two references to "a" must result in a single loadstorage

// BEGIN-CHECK: deadstorage::function::test1
	function test1() public view returns (int) {
        return a + a;
	}
// CHECK: load storage slot(uint256 0) ty:int256
// NOT-CHECK: load storage slot(uint256 0) ty:int256

    // Two references to "a" with a write to A in between must result in two loadstorage
// BEGIN-CHECK: deadstorage::function::test2
	function test2() public returns (int) {
        int x = a;
        a = 2;
        x += a;
        return x;
	}
// CHECK: load storage slot(uint256 0) ty:int256
// CHECK: load storage slot(uint256 0) ty:int256

    // make sure that reachable stores are not eliminated
// BEGIN-CHECK: deadstorage::function::test3
	function test3(bool c) public {
		a = 1;
		if (c) {
			a = 2;
		}
	}
// CHECK: store storage slot(uint256 0)
// CHECK: store storage slot(uint256 0)

   // two successive stores are redundant
// BEGIN-CHECK: deadstorage::function::test4
    int b;
	function test4() public returns (int) {
		b = 511;
	    b = 512;
        return b;
	}
// CHECK: store storage slot(uint256 1)
// NOT-CHECK: store storage slot(uint256 1)

   // stores in a previous block are always redundant
// BEGIN-CHECK: deadstorage::function::test5
    int test5var;
	function test5(bool c) public returns (int) {
        if (c) {
            test5var = 1;
        } else {
            test5var = 2;
        }
        test5var = 3;

        return test5var;
	}
// CHECK: store storage slot(uint256 2)
// NOT-CHECK: store storage slot(uint256 2)

// BEGIN-CHECK: deadstorage::function::test6
    // store/load are not merged yet. Make sure that we have a store before a load
    int test6var;
    function test6() public returns (int) {
        test6var = 1;
        int f = test6var;
        test6var = 2;
        return test6var + f;
    }
// CHECK: store storage slot(uint256 3)
// CHECK: store storage slot(uint256 3)

// BEGIN-CHECK: deadstorage::function::test7
    // storage should be flushed before function call
    int test7var;
    function test7() public returns (int) {
        test7var = 1;
        test6();
        test7var = 2;
        return test7var;
    }
// CHECK: store storage slot(uint256 4)
// CHECK: store storage slot(uint256 4)

// BEGIN-CHECK: deadstorage::function::test8
    // clear before store is redundant
    int test8var;
    function test8() public {
        delete test8var;
        test8var = 2;
    }
// NOT-CHECK: clear storage slot(uint256 5)
// CHECK: store storage slot(uint256 5)

// BEGIN-CHECK: deadstorage::function::test9
    // push should make both load/stores not redundant
    bytes test9var;
    function test9() public returns (bytes){
        test9var = "a";
        bytes f = test9var;
        test9var.push(hex"01");
        f = test9var;
        test9var = "c";

        return f;
    }
// CHECK: store storage slot(uint256 6)
// CHECK: load storage slot(uint256 6)
// CHECK: push storage ty:bytes1 slot:uint256 6
// CHECK: load storage slot(uint256 6)
// CHECK: store storage slot(uint256 6)

// BEGIN-CHECK: deadstorage::function::test10
    // pop should make both load/stores not redundant
    bytes test10var;
    function test10() public returns (bytes) {
        test10var = "a";
        bytes f = test10var;
        test10var.pop();
        f = test10var;
        test10var = "c";

        return f;
    }
// CHECK: store storage slot(uint256 7)
// CHECK: load storage slot(uint256 7)
// CHECK: pop storage ty:bytes1 slot(uint256 7)
// CHECK: load storage slot(uint256 7)
// CHECK: store storage slot(uint256 7)

// BEGIN-CHECK: deadstorage::function::test11
    // some array tests
    int[11] test11var;
    function test11(uint index, uint index2) public view returns (int) {
        return test11var[index] + test11var[index2];
    }

// CHECK: load storage slot((uint256 8
// CHECK: load storage slot((uint256 8

// BEGIN-CHECK: deadstorage::function::test12
    // one load needed for this
    int[11] test12var;
    function test12(uint index) public view returns (int) {
        return test12var[index] + test12var[index];

    }
// CHECK: load storage slot((uint256 19
// NOT-CHECK: load storage slot((uint256 19
}

contract foo {
    struct S { int32 f1; }
        S[] arr;

    function g() private returns (S storage, S storage) {
        return (arr[0], arr[1]);
    }
// BEGIN-CHECK: foo::foo::function::f
    function f() public returns (S, S) {
        S[] storage ptrArr = arr;
        ptrArr.push(S({f1: 1}));
        ptrArr.push(S({f1: 2}));
// CHECK: %.temp.76, %.temp.77 = call foo::foo::function::g
// CHECK: %temp.78 = load storage slot(%.temp.76) ty:struct foo.S
// CHECK: %temp.79 = load storage slot(%.temp.77) ty:struct foo.S
        return g();
    }
}