ethereum.forks.homestead.vm.instructions.stackethereum.forks.dao_fork.vm.instructions.stack

Ethereum Virtual Machine (EVM) Stack Instructions.

.. contents:: Table of Contents :backlinks: none :local:

Introduction

Implementations of the EVM stack related instructions.

pop

Removes an item from the stack.

Parameters

evm : The current EVM frame.

def pop(​evm: Evm​) -> None:
29
    <snip>
38
    # STACK
39
    stack.pop(evm.stack)
40
41
    # GAS
42
    charge_gas(evm, GasCosts.OPCODE_POP)
43
44
    # OPERATION
45
    pass
46
47
    # PROGRAM COUNTER
48
    evm.pc += Uint(1)

push_n

Pushes an N-byte immediate onto the stack.

Parameters

evm : The current EVM frame.

num_bytes : The number of immediate bytes to be read from the code and pushed to the stack.

def push_n(​evm: Evm, ​​num_bytes: int​) -> None:
52
    <snip>
65
    # STACK
66
    pass
67
68
    # GAS
69
    charge_gas(evm, GasCosts.OPCODE_PUSH)
70
71
    # OPERATION
72
    data_to_push = U256.from_be_bytes(
73
        buffer_read(evm.code, U256(evm.pc + Uint(1)), U256(num_bytes))
74
    )
75
    stack.push(evm.stack, data_to_push)
76
77
    # PROGRAM COUNTER
78
    evm.pc += Uint(1) + Uint(num_bytes)

dup_n

Duplicates the Nth stack item (from top of the stack) to the top of stack.

Parameters

evm : The current EVM frame.

item_number : The stack item number (0-indexed from top of stack) to be duplicated to the top of stack.

def dup_n(​evm: Evm, ​​item_number: int​) -> None:
82
    <snip>
95
    # STACK
96
    pass
97
98
    # GAS
99
    charge_gas(evm, GasCosts.OPCODE_DUP)
100
    if item_number >= len(evm.stack):
101
        raise StackUnderflowError
102
    data_to_duplicate = evm.stack[len(evm.stack) - 1 - item_number]
103
    stack.push(evm.stack, data_to_duplicate)
104
105
    # PROGRAM COUNTER
106
    evm.pc += Uint(1)

swap_n

Swaps the top and the item_number element of the stack, where the top of the stack is position zero.

If item_number is zero, this function does nothing (which should not be possible, since there is no SWAP0 instruction).

Parameters

evm : The current EVM frame.

item_number : The stack item number (0-indexed from top of stack) to be swapped with the top of stack element.

def swap_n(​evm: Evm, ​​item_number: int​) -> None:
110
    <snip>
127
    # STACK
128
    pass
129
130
    # GAS
131
    charge_gas(evm, GasCosts.OPCODE_SWAP)
132
    if item_number >= len(evm.stack):
133
        raise StackUnderflowError
134
    evm.stack[-1], evm.stack[-1 - item_number] = (
135
        evm.stack[-1 - item_number],
136
        evm.stack[-1],
137
    )
138
139
    # PROGRAM COUNTER
140
    evm.pc += Uint(1)

push1

143
push1: Callable[[Evm], None] = partial(push_n, num_bytes=1)

push2

144
push2: Callable[[Evm], None] = partial(push_n, num_bytes=2)

push3

145
push3: Callable[[Evm], None] = partial(push_n, num_bytes=3)

push4

146
push4: Callable[[Evm], None] = partial(push_n, num_bytes=4)

push5

147
push5: Callable[[Evm], None] = partial(push_n, num_bytes=5)

push6

148
push6: Callable[[Evm], None] = partial(push_n, num_bytes=6)

push7

149
push7: Callable[[Evm], None] = partial(push_n, num_bytes=7)

push8

150
push8: Callable[[Evm], None] = partial(push_n, num_bytes=8)

push9

151
push9: Callable[[Evm], None] = partial(push_n, num_bytes=9)

push10

152
push10: Callable[[Evm], None] = partial(push_n, num_bytes=10)

push11

153
push11: Callable[[Evm], None] = partial(push_n, num_bytes=11)

push12

154
push12: Callable[[Evm], None] = partial(push_n, num_bytes=12)

push13

155
push13: Callable[[Evm], None] = partial(push_n, num_bytes=13)

push14

156
push14: Callable[[Evm], None] = partial(push_n, num_bytes=14)

push15

157
push15: Callable[[Evm], None] = partial(push_n, num_bytes=15)

push16

158
push16: Callable[[Evm], None] = partial(push_n, num_bytes=16)

push17

159
push17: Callable[[Evm], None] = partial(push_n, num_bytes=17)

push18

160
push18: Callable[[Evm], None] = partial(push_n, num_bytes=18)

push19

161
push19: Callable[[Evm], None] = partial(push_n, num_bytes=19)

push20

162
push20: Callable[[Evm], None] = partial(push_n, num_bytes=20)

push21

163
push21: Callable[[Evm], None] = partial(push_n, num_bytes=21)

push22

164
push22: Callable[[Evm], None] = partial(push_n, num_bytes=22)

push23

165
push23: Callable[[Evm], None] = partial(push_n, num_bytes=23)

push24

166
push24: Callable[[Evm], None] = partial(push_n, num_bytes=24)

push25

167
push25: Callable[[Evm], None] = partial(push_n, num_bytes=25)

push26

168
push26: Callable[[Evm], None] = partial(push_n, num_bytes=26)

push27

169
push27: Callable[[Evm], None] = partial(push_n, num_bytes=27)

push28

170
push28: Callable[[Evm], None] = partial(push_n, num_bytes=28)

push29

171
push29: Callable[[Evm], None] = partial(push_n, num_bytes=29)

push30

172
push30: Callable[[Evm], None] = partial(push_n, num_bytes=30)

push31

173
push31: Callable[[Evm], None] = partial(push_n, num_bytes=31)

push32

174
push32: Callable[[Evm], None] = partial(push_n, num_bytes=32)

dup1

176
dup1: Callable[[Evm], None] = partial(dup_n, item_number=0)

dup2

177
dup2: Callable[[Evm], None] = partial(dup_n, item_number=1)

dup3

178
dup3: Callable[[Evm], None] = partial(dup_n, item_number=2)

dup4

179
dup4: Callable[[Evm], None] = partial(dup_n, item_number=3)

dup5

180
dup5: Callable[[Evm], None] = partial(dup_n, item_number=4)

dup6

181
dup6: Callable[[Evm], None] = partial(dup_n, item_number=5)

dup7

182
dup7: Callable[[Evm], None] = partial(dup_n, item_number=6)

dup8

183
dup8: Callable[[Evm], None] = partial(dup_n, item_number=7)

dup9

184
dup9: Callable[[Evm], None] = partial(dup_n, item_number=8)

dup10

185
dup10: Callable[[Evm], None] = partial(dup_n, item_number=9)

dup11

186
dup11: Callable[[Evm], None] = partial(dup_n, item_number=10)

dup12

187
dup12: Callable[[Evm], None] = partial(dup_n, item_number=11)

dup13

188
dup13: Callable[[Evm], None] = partial(dup_n, item_number=12)

dup14

189
dup14: Callable[[Evm], None] = partial(dup_n, item_number=13)

dup15

190
dup15: Callable[[Evm], None] = partial(dup_n, item_number=14)

dup16

191
dup16: Callable[[Evm], None] = partial(dup_n, item_number=15)

swap1

193
swap1: Callable[[Evm], None] = partial(swap_n, item_number=1)

swap2

194
swap2: Callable[[Evm], None] = partial(swap_n, item_number=2)

swap3

195
swap3: Callable[[Evm], None] = partial(swap_n, item_number=3)

swap4

196
swap4: Callable[[Evm], None] = partial(swap_n, item_number=4)

swap5

197
swap5: Callable[[Evm], None] = partial(swap_n, item_number=5)

swap6

198
swap6: Callable[[Evm], None] = partial(swap_n, item_number=6)

swap7

199
swap7: Callable[[Evm], None] = partial(swap_n, item_number=7)

swap8

200
swap8: Callable[[Evm], None] = partial(swap_n, item_number=8)

swap9

201
swap9: Callable[[Evm], None] = partial(swap_n, item_number=9)

swap10

202
swap10: Callable[[Evm], None] = partial(swap_n, item_number=10)

swap11

203
swap11: Callable[[Evm], None] = partial(swap_n, item_number=11)

swap12

204
swap12: Callable[[Evm], None] = partial(swap_n, item_number=12)

swap13

205
swap13: Callable[[Evm], None] = partial(swap_n, item_number=13)

swap14

206
swap14: Callable[[Evm], None] = partial(swap_n, item_number=14)

swap15

207
swap15: Callable[[Evm], None] = partial(swap_n, item_number=15)

swap16

208
swap16: Callable[[Evm], None] = partial(swap_n, item_number=16)