github.com/oskarth/go-ethereum@v1.6.8-0.20191013093314-dac24a9d3494/core/vm/instructions.go (about) 1 // Copyright 2015 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package vm 18 19 import ( 20 "errors" 21 "fmt" 22 "math/big" 23 24 "github.com/ethereum/go-ethereum/common" 25 "github.com/ethereum/go-ethereum/common/math" 26 "github.com/ethereum/go-ethereum/core/types" 27 "github.com/ethereum/go-ethereum/crypto/sha3" 28 "github.com/ethereum/go-ethereum/params" 29 ) 30 31 var ( 32 bigZero = new(big.Int) 33 tt255 = math.BigPow(2, 255) 34 errWriteProtection = errors.New("evm: write protection") 35 errReturnDataOutOfBounds = errors.New("evm: return data out of bounds") 36 errExecutionReverted = errors.New("evm: execution reverted") 37 errMaxCodeSizeExceeded = errors.New("evm: max code size exceeded") 38 ) 39 40 func opAdd(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 41 x, y := stack.pop(), stack.peek() 42 math.U256(y.Add(x, y)) 43 44 interpreter.intPool.put(x) 45 return nil, nil 46 } 47 48 func opSub(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 49 x, y := stack.pop(), stack.peek() 50 math.U256(y.Sub(x, y)) 51 52 interpreter.intPool.put(x) 53 return nil, nil 54 } 55 56 func opMul(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 57 x, y := stack.pop(), stack.pop() 58 stack.push(math.U256(x.Mul(x, y))) 59 60 interpreter.intPool.put(y) 61 62 return nil, nil 63 } 64 65 func opDiv(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 66 x, y := stack.pop(), stack.peek() 67 if y.Sign() != 0 { 68 math.U256(y.Div(x, y)) 69 } else { 70 y.SetUint64(0) 71 } 72 interpreter.intPool.put(x) 73 return nil, nil 74 } 75 76 func opSdiv(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 77 x, y := math.S256(stack.pop()), math.S256(stack.pop()) 78 res := interpreter.intPool.getZero() 79 80 if y.Sign() == 0 || x.Sign() == 0 { 81 stack.push(res) 82 } else { 83 if x.Sign() != y.Sign() { 84 res.Div(x.Abs(x), y.Abs(y)) 85 res.Neg(res) 86 } else { 87 res.Div(x.Abs(x), y.Abs(y)) 88 } 89 stack.push(math.U256(res)) 90 } 91 interpreter.intPool.put(x, y) 92 return nil, nil 93 } 94 95 func opMod(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 96 x, y := stack.pop(), stack.pop() 97 if y.Sign() == 0 { 98 stack.push(x.SetUint64(0)) 99 } else { 100 stack.push(math.U256(x.Mod(x, y))) 101 } 102 interpreter.intPool.put(y) 103 return nil, nil 104 } 105 106 func opSmod(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 107 x, y := math.S256(stack.pop()), math.S256(stack.pop()) 108 res := interpreter.intPool.getZero() 109 110 if y.Sign() == 0 { 111 stack.push(res) 112 } else { 113 if x.Sign() < 0 { 114 res.Mod(x.Abs(x), y.Abs(y)) 115 res.Neg(res) 116 } else { 117 res.Mod(x.Abs(x), y.Abs(y)) 118 } 119 stack.push(math.U256(res)) 120 } 121 interpreter.intPool.put(x, y) 122 return nil, nil 123 } 124 125 func opExp(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 126 base, exponent := stack.pop(), stack.pop() 127 // some shortcuts 128 cmpToOne := exponent.Cmp(big1) 129 if cmpToOne < 0 { // Exponent is zero 130 // x ^ 0 == 1 131 stack.push(base.SetUint64(1)) 132 } else if base.Sign() == 0 { 133 // 0 ^ y, if y != 0, == 0 134 stack.push(base.SetUint64(0)) 135 } else if cmpToOne == 0 { // Exponent is one 136 // x ^ 1 == x 137 stack.push(base) 138 } else { 139 stack.push(math.Exp(base, exponent)) 140 interpreter.intPool.put(base) 141 } 142 interpreter.intPool.put(exponent) 143 return nil, nil 144 } 145 146 func opSignExtend(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 147 back := stack.pop() 148 if back.Cmp(big.NewInt(31)) < 0 { 149 bit := uint(back.Uint64()*8 + 7) 150 num := stack.pop() 151 mask := back.Lsh(common.Big1, bit) 152 mask.Sub(mask, common.Big1) 153 if num.Bit(int(bit)) > 0 { 154 num.Or(num, mask.Not(mask)) 155 } else { 156 num.And(num, mask) 157 } 158 159 stack.push(math.U256(num)) 160 } 161 162 interpreter.intPool.put(back) 163 return nil, nil 164 } 165 166 func opNot(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 167 x := stack.peek() 168 math.U256(x.Not(x)) 169 return nil, nil 170 } 171 172 func opLt(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 173 x, y := stack.pop(), stack.peek() 174 if x.Cmp(y) < 0 { 175 y.SetUint64(1) 176 } else { 177 y.SetUint64(0) 178 } 179 interpreter.intPool.put(x) 180 return nil, nil 181 } 182 183 func opGt(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 184 x, y := stack.pop(), stack.peek() 185 if x.Cmp(y) > 0 { 186 y.SetUint64(1) 187 } else { 188 y.SetUint64(0) 189 } 190 interpreter.intPool.put(x) 191 return nil, nil 192 } 193 194 func opSlt(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 195 x, y := stack.pop(), stack.peek() 196 197 xSign := x.Cmp(tt255) 198 ySign := y.Cmp(tt255) 199 200 switch { 201 case xSign >= 0 && ySign < 0: 202 y.SetUint64(1) 203 204 case xSign < 0 && ySign >= 0: 205 y.SetUint64(0) 206 207 default: 208 if x.Cmp(y) < 0 { 209 y.SetUint64(1) 210 } else { 211 y.SetUint64(0) 212 } 213 } 214 interpreter.intPool.put(x) 215 return nil, nil 216 } 217 218 func opSgt(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 219 x, y := stack.pop(), stack.peek() 220 221 xSign := x.Cmp(tt255) 222 ySign := y.Cmp(tt255) 223 224 switch { 225 case xSign >= 0 && ySign < 0: 226 y.SetUint64(0) 227 228 case xSign < 0 && ySign >= 0: 229 y.SetUint64(1) 230 231 default: 232 if x.Cmp(y) > 0 { 233 y.SetUint64(1) 234 } else { 235 y.SetUint64(0) 236 } 237 } 238 interpreter.intPool.put(x) 239 return nil, nil 240 } 241 242 func opEq(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 243 x, y := stack.pop(), stack.peek() 244 if x.Cmp(y) == 0 { 245 y.SetUint64(1) 246 } else { 247 y.SetUint64(0) 248 } 249 interpreter.intPool.put(x) 250 return nil, nil 251 } 252 253 func opIszero(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 254 x := stack.peek() 255 if x.Sign() > 0 { 256 x.SetUint64(0) 257 } else { 258 x.SetUint64(1) 259 } 260 return nil, nil 261 } 262 263 func opAnd(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 264 x, y := stack.pop(), stack.pop() 265 stack.push(x.And(x, y)) 266 267 interpreter.intPool.put(y) 268 return nil, nil 269 } 270 271 func opOr(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 272 x, y := stack.pop(), stack.peek() 273 y.Or(x, y) 274 275 interpreter.intPool.put(x) 276 return nil, nil 277 } 278 279 func opXor(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 280 x, y := stack.pop(), stack.peek() 281 y.Xor(x, y) 282 283 interpreter.intPool.put(x) 284 return nil, nil 285 } 286 287 func opByte(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 288 th, val := stack.pop(), stack.peek() 289 if th.Cmp(common.Big32) < 0 { 290 b := math.Byte(val, 32, int(th.Int64())) 291 val.SetUint64(uint64(b)) 292 } else { 293 val.SetUint64(0) 294 } 295 interpreter.intPool.put(th) 296 return nil, nil 297 } 298 299 func opAddmod(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 300 x, y, z := stack.pop(), stack.pop(), stack.pop() 301 if z.Cmp(bigZero) > 0 { 302 x.Add(x, y) 303 x.Mod(x, z) 304 stack.push(math.U256(x)) 305 } else { 306 stack.push(x.SetUint64(0)) 307 } 308 interpreter.intPool.put(y, z) 309 return nil, nil 310 } 311 312 func opMulmod(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 313 x, y, z := stack.pop(), stack.pop(), stack.pop() 314 if z.Cmp(bigZero) > 0 { 315 x.Mul(x, y) 316 x.Mod(x, z) 317 stack.push(math.U256(x)) 318 } else { 319 stack.push(x.SetUint64(0)) 320 } 321 interpreter.intPool.put(y, z) 322 return nil, nil 323 } 324 325 // opSHL implements Shift Left 326 // The SHL instruction (shift left) pops 2 values from the stack, first arg1 and then arg2, 327 // and pushes on the stack arg2 shifted to the left by arg1 number of bits. 328 func opSHL(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 329 // Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards 330 shift, value := math.U256(stack.pop()), math.U256(stack.peek()) 331 defer interpreter.intPool.put(shift) // First operand back into the pool 332 333 if shift.Cmp(common.Big256) >= 0 { 334 value.SetUint64(0) 335 return nil, nil 336 } 337 n := uint(shift.Uint64()) 338 math.U256(value.Lsh(value, n)) 339 340 return nil, nil 341 } 342 343 // opSHR implements Logical Shift Right 344 // The SHR instruction (logical shift right) pops 2 values from the stack, first arg1 and then arg2, 345 // and pushes on the stack arg2 shifted to the right by arg1 number of bits with zero fill. 346 func opSHR(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 347 // Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards 348 shift, value := math.U256(stack.pop()), math.U256(stack.peek()) 349 defer interpreter.intPool.put(shift) // First operand back into the pool 350 351 if shift.Cmp(common.Big256) >= 0 { 352 value.SetUint64(0) 353 return nil, nil 354 } 355 n := uint(shift.Uint64()) 356 math.U256(value.Rsh(value, n)) 357 358 return nil, nil 359 } 360 361 // opSAR implements Arithmetic Shift Right 362 // The SAR instruction (arithmetic shift right) pops 2 values from the stack, first arg1 and then arg2, 363 // and pushes on the stack arg2 shifted to the right by arg1 number of bits with sign extension. 364 func opSAR(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 365 // Note, S256 returns (potentially) a new bigint, so we're popping, not peeking this one 366 shift, value := math.U256(stack.pop()), math.S256(stack.pop()) 367 defer interpreter.intPool.put(shift) // First operand back into the pool 368 369 if shift.Cmp(common.Big256) >= 0 { 370 if value.Sign() >= 0 { 371 value.SetUint64(0) 372 } else { 373 value.SetInt64(-1) 374 } 375 stack.push(math.U256(value)) 376 return nil, nil 377 } 378 n := uint(shift.Uint64()) 379 value.Rsh(value, n) 380 stack.push(math.U256(value)) 381 382 return nil, nil 383 } 384 385 func opSha3(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 386 offset, size := stack.pop(), stack.pop() 387 data := memory.Get(offset.Int64(), size.Int64()) 388 389 if interpreter.hasher == nil { 390 interpreter.hasher = sha3.NewKeccak256().(keccakState) 391 } else { 392 interpreter.hasher.Reset() 393 } 394 interpreter.hasher.Write(data) 395 interpreter.hasher.Read(interpreter.hasherBuf[:]) 396 397 evm := interpreter.evm 398 if evm.vmConfig.EnablePreimageRecording { 399 evm.StateDB.AddPreimage(interpreter.hasherBuf, data) 400 } 401 stack.push(interpreter.intPool.get().SetBytes(interpreter.hasherBuf[:])) 402 403 interpreter.intPool.put(offset, size) 404 return nil, nil 405 } 406 407 func opAddress(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 408 stack.push(contract.Address().Big()) 409 return nil, nil 410 } 411 412 func opBalance(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 413 slot := stack.peek() 414 slot.Set(interpreter.evm.StateDB.GetBalance(common.BigToAddress(slot))) 415 return nil, nil 416 } 417 418 func opOrigin(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 419 stack.push(interpreter.evm.Origin.Big()) 420 return nil, nil 421 } 422 423 func opCaller(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 424 stack.push(contract.Caller().Big()) 425 return nil, nil 426 } 427 428 func opCallValue(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 429 stack.push(interpreter.intPool.get().Set(contract.value)) 430 return nil, nil 431 } 432 433 func opCallDataLoad(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 434 stack.push(interpreter.intPool.get().SetBytes(getDataBig(contract.Input, stack.pop(), big32))) 435 return nil, nil 436 } 437 438 func opCallDataSize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 439 stack.push(interpreter.intPool.get().SetInt64(int64(len(contract.Input)))) 440 return nil, nil 441 } 442 443 func opCallDataCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 444 var ( 445 memOffset = stack.pop() 446 dataOffset = stack.pop() 447 length = stack.pop() 448 ) 449 memory.Set(memOffset.Uint64(), length.Uint64(), getDataBig(contract.Input, dataOffset, length)) 450 451 interpreter.intPool.put(memOffset, dataOffset, length) 452 return nil, nil 453 } 454 455 func opReturnDataSize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 456 stack.push(interpreter.intPool.get().SetUint64(uint64(len(interpreter.returnData)))) 457 return nil, nil 458 } 459 460 func opReturnDataCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 461 var ( 462 memOffset = stack.pop() 463 dataOffset = stack.pop() 464 length = stack.pop() 465 466 end = interpreter.intPool.get().Add(dataOffset, length) 467 ) 468 defer interpreter.intPool.put(memOffset, dataOffset, length, end) 469 470 if end.BitLen() > 64 || uint64(len(interpreter.returnData)) < end.Uint64() { 471 return nil, errReturnDataOutOfBounds 472 } 473 memory.Set(memOffset.Uint64(), length.Uint64(), interpreter.returnData[dataOffset.Uint64():end.Uint64()]) 474 475 return nil, nil 476 } 477 478 func opExtCodeSize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 479 slot := stack.peek() 480 slot.SetUint64(uint64(interpreter.evm.StateDB.GetCodeSize(common.BigToAddress(slot)))) 481 482 return nil, nil 483 } 484 485 func opCodeSize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 486 l := interpreter.intPool.get().SetInt64(int64(len(contract.Code))) 487 stack.push(l) 488 489 return nil, nil 490 } 491 492 func opCodeCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 493 var ( 494 memOffset = stack.pop() 495 codeOffset = stack.pop() 496 length = stack.pop() 497 ) 498 codeCopy := getDataBig(contract.Code, codeOffset, length) 499 memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy) 500 501 interpreter.intPool.put(memOffset, codeOffset, length) 502 return nil, nil 503 } 504 505 func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 506 var ( 507 addr = common.BigToAddress(stack.pop()) 508 memOffset = stack.pop() 509 codeOffset = stack.pop() 510 length = stack.pop() 511 ) 512 codeCopy := getDataBig(interpreter.evm.StateDB.GetCode(addr), codeOffset, length) 513 memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy) 514 515 interpreter.intPool.put(memOffset, codeOffset, length) 516 return nil, nil 517 } 518 519 // opExtCodeHash returns the code hash of a specified account. 520 // There are several cases when the function is called, while we can relay everything 521 // to `state.GetCodeHash` function to ensure the correctness. 522 // (1) Caller tries to get the code hash of a normal contract account, state 523 // should return the relative code hash and set it as the result. 524 // 525 // (2) Caller tries to get the code hash of a non-existent account, state should 526 // return common.Hash{} and zero will be set as the result. 527 // 528 // (3) Caller tries to get the code hash for an account without contract code, 529 // state should return emptyCodeHash(0xc5d246...) as the result. 530 // 531 // (4) Caller tries to get the code hash of a precompiled account, the result 532 // should be zero or emptyCodeHash. 533 // 534 // It is worth noting that in order to avoid unnecessary create and clean, 535 // all precompile accounts on mainnet have been transferred 1 wei, so the return 536 // here should be emptyCodeHash. 537 // If the precompile account is not transferred any amount on a private or 538 // customized chain, the return value will be zero. 539 // 540 // (5) Caller tries to get the code hash for an account which is marked as suicided 541 // in the current transaction, the code hash of this account should be returned. 542 // 543 // (6) Caller tries to get the code hash for an account which is marked as deleted, 544 // this account should be regarded as a non-existent account and zero should be returned. 545 func opExtCodeHash(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 546 slot := stack.peek() 547 slot.SetBytes(interpreter.evm.StateDB.GetCodeHash(common.BigToAddress(slot)).Bytes()) 548 return nil, nil 549 } 550 551 func opGasprice(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 552 stack.push(interpreter.intPool.get().Set(interpreter.evm.GasPrice)) 553 return nil, nil 554 } 555 556 func opBlockhash(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 557 num := stack.pop() 558 559 n := interpreter.intPool.get().Sub(interpreter.evm.BlockNumber, common.Big257) 560 if num.Cmp(n) > 0 && num.Cmp(interpreter.evm.BlockNumber) < 0 { 561 stack.push(interpreter.evm.GetHash(num.Uint64()).Big()) 562 } else { 563 stack.push(interpreter.intPool.getZero()) 564 } 565 interpreter.intPool.put(num, n) 566 return nil, nil 567 } 568 569 func opCoinbase(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 570 stack.push(interpreter.evm.Coinbase.Big()) 571 return nil, nil 572 } 573 574 func opTimestamp(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 575 stack.push(math.U256(interpreter.intPool.get().Set(interpreter.evm.Time))) 576 return nil, nil 577 } 578 579 func opNumber(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 580 stack.push(math.U256(interpreter.intPool.get().Set(interpreter.evm.BlockNumber))) 581 return nil, nil 582 } 583 584 func opDifficulty(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 585 stack.push(math.U256(interpreter.intPool.get().Set(interpreter.evm.Difficulty))) 586 return nil, nil 587 } 588 589 func opGasLimit(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 590 stack.push(math.U256(interpreter.intPool.get().SetUint64(interpreter.evm.GasLimit))) 591 return nil, nil 592 } 593 594 func opPop(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 595 interpreter.intPool.put(stack.pop()) 596 return nil, nil 597 } 598 599 func opMload(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 600 offset := stack.pop() 601 val := interpreter.intPool.get().SetBytes(memory.Get(offset.Int64(), 32)) 602 stack.push(val) 603 604 interpreter.intPool.put(offset) 605 return nil, nil 606 } 607 608 func opMstore(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 609 // pop value of the stack 610 mStart, val := stack.pop(), stack.pop() 611 memory.Set32(mStart.Uint64(), val) 612 613 interpreter.intPool.put(mStart, val) 614 return nil, nil 615 } 616 617 func opMstore8(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 618 off, val := stack.pop().Int64(), stack.pop().Int64() 619 memory.store[off] = byte(val & 0xff) 620 621 return nil, nil 622 } 623 624 func opSload(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 625 loc := stack.peek() 626 val := interpreter.evm.StateDB.GetState(contract.Address(), common.BigToHash(loc)) 627 loc.SetBytes(val.Bytes()) 628 return nil, nil 629 } 630 631 func opSstore(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 632 loc := common.BigToHash(stack.pop()) 633 val := stack.pop() 634 interpreter.evm.StateDB.SetState(contract.Address(), loc, common.BigToHash(val)) 635 636 interpreter.intPool.put(val) 637 return nil, nil 638 } 639 640 func opJump(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 641 pos := stack.pop() 642 if !contract.validJumpdest(pos) { 643 nop := contract.GetOp(pos.Uint64()) 644 return nil, fmt.Errorf("invalid jump destination (%v) %v", nop, pos) 645 } 646 *pc = pos.Uint64() 647 648 interpreter.intPool.put(pos) 649 return nil, nil 650 } 651 652 func opJumpi(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 653 pos, cond := stack.pop(), stack.pop() 654 if cond.Sign() != 0 { 655 if !contract.validJumpdest(pos) { 656 nop := contract.GetOp(pos.Uint64()) 657 return nil, fmt.Errorf("invalid jump destination (%v) %v", nop, pos) 658 } 659 *pc = pos.Uint64() 660 } else { 661 *pc++ 662 } 663 664 interpreter.intPool.put(pos, cond) 665 return nil, nil 666 } 667 668 func opJumpdest(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 669 return nil, nil 670 } 671 672 func opPc(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 673 stack.push(interpreter.intPool.get().SetUint64(*pc)) 674 return nil, nil 675 } 676 677 func opMsize(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 678 stack.push(interpreter.intPool.get().SetInt64(int64(memory.Len()))) 679 return nil, nil 680 } 681 682 func opGas(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 683 stack.push(interpreter.intPool.get().SetUint64(contract.Gas)) 684 return nil, nil 685 } 686 687 func opCreate(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 688 var ( 689 value = stack.pop() 690 offset, size = stack.pop(), stack.pop() 691 input = memory.Get(offset.Int64(), size.Int64()) 692 gas = contract.Gas 693 ) 694 if interpreter.evm.ChainConfig().IsEIP150(interpreter.evm.BlockNumber) { 695 gas -= gas / 64 696 } 697 698 contract.UseGas(gas) 699 res, addr, returnGas, suberr := interpreter.evm.Create(contract, input, gas, value) 700 // Push item on the stack based on the returned error. If the ruleset is 701 // homestead we must check for CodeStoreOutOfGasError (homestead only 702 // rule) and treat as an error, if the ruleset is frontier we must 703 // ignore this error and pretend the operation was successful. 704 if interpreter.evm.ChainConfig().IsHomestead(interpreter.evm.BlockNumber) && suberr == ErrCodeStoreOutOfGas { 705 stack.push(interpreter.intPool.getZero()) 706 } else if suberr != nil && suberr != ErrCodeStoreOutOfGas { 707 stack.push(interpreter.intPool.getZero()) 708 } else { 709 stack.push(addr.Big()) 710 } 711 contract.Gas += returnGas 712 interpreter.intPool.put(value, offset, size) 713 714 if suberr == errExecutionReverted { 715 return res, nil 716 } 717 return nil, nil 718 } 719 720 func opCreate2(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 721 var ( 722 endowment = stack.pop() 723 offset, size = stack.pop(), stack.pop() 724 salt = stack.pop() 725 input = memory.Get(offset.Int64(), size.Int64()) 726 gas = contract.Gas 727 ) 728 729 // Apply EIP150 730 gas -= gas / 64 731 contract.UseGas(gas) 732 res, addr, returnGas, suberr := interpreter.evm.Create2(contract, input, gas, endowment, salt) 733 // Push item on the stack based on the returned error. 734 if suberr != nil { 735 stack.push(interpreter.intPool.getZero()) 736 } else { 737 stack.push(addr.Big()) 738 } 739 contract.Gas += returnGas 740 interpreter.intPool.put(endowment, offset, size, salt) 741 742 if suberr == errExecutionReverted { 743 return res, nil 744 } 745 return nil, nil 746 } 747 748 func opCall(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 749 // Pop gas. The actual gas in interpreter.evm.callGasTemp. 750 interpreter.intPool.put(stack.pop()) 751 gas := interpreter.evm.callGasTemp 752 // Pop other call parameters. 753 addr, value, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop() 754 toAddr := common.BigToAddress(addr) 755 value = math.U256(value) 756 // Get the arguments from the memory. 757 args := memory.Get(inOffset.Int64(), inSize.Int64()) 758 759 if value.Sign() != 0 { 760 gas += params.CallStipend 761 } 762 ret, returnGas, err := interpreter.evm.Call(contract, toAddr, args, gas, value) 763 if err != nil { 764 stack.push(interpreter.intPool.getZero()) 765 } else { 766 stack.push(interpreter.intPool.get().SetUint64(1)) 767 } 768 if err == nil || err == errExecutionReverted { 769 memory.Set(retOffset.Uint64(), retSize.Uint64(), ret) 770 } 771 contract.Gas += returnGas 772 773 interpreter.intPool.put(addr, value, inOffset, inSize, retOffset, retSize) 774 return ret, nil 775 } 776 777 func opCallCode(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 778 // Pop gas. The actual gas is in interpreter.evm.callGasTemp. 779 interpreter.intPool.put(stack.pop()) 780 gas := interpreter.evm.callGasTemp 781 // Pop other call parameters. 782 addr, value, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop() 783 toAddr := common.BigToAddress(addr) 784 value = math.U256(value) 785 // Get arguments from the memory. 786 args := memory.Get(inOffset.Int64(), inSize.Int64()) 787 788 if value.Sign() != 0 { 789 gas += params.CallStipend 790 } 791 ret, returnGas, err := interpreter.evm.CallCode(contract, toAddr, args, gas, value) 792 if err != nil { 793 stack.push(interpreter.intPool.getZero()) 794 } else { 795 stack.push(interpreter.intPool.get().SetUint64(1)) 796 } 797 if err == nil || err == errExecutionReverted { 798 memory.Set(retOffset.Uint64(), retSize.Uint64(), ret) 799 } 800 contract.Gas += returnGas 801 802 interpreter.intPool.put(addr, value, inOffset, inSize, retOffset, retSize) 803 return ret, nil 804 } 805 806 func opDelegateCall(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 807 // Pop gas. The actual gas is in interpreter.evm.callGasTemp. 808 interpreter.intPool.put(stack.pop()) 809 gas := interpreter.evm.callGasTemp 810 // Pop other call parameters. 811 addr, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop() 812 toAddr := common.BigToAddress(addr) 813 // Get arguments from the memory. 814 args := memory.Get(inOffset.Int64(), inSize.Int64()) 815 816 ret, returnGas, err := interpreter.evm.DelegateCall(contract, toAddr, args, gas) 817 if err != nil { 818 stack.push(interpreter.intPool.getZero()) 819 } else { 820 stack.push(interpreter.intPool.get().SetUint64(1)) 821 } 822 if err == nil || err == errExecutionReverted { 823 memory.Set(retOffset.Uint64(), retSize.Uint64(), ret) 824 } 825 contract.Gas += returnGas 826 827 interpreter.intPool.put(addr, inOffset, inSize, retOffset, retSize) 828 return ret, nil 829 } 830 831 func opStaticCall(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 832 // Pop gas. The actual gas is in interpreter.evm.callGasTemp. 833 interpreter.intPool.put(stack.pop()) 834 gas := interpreter.evm.callGasTemp 835 // Pop other call parameters. 836 addr, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop() 837 toAddr := common.BigToAddress(addr) 838 // Get arguments from the memory. 839 args := memory.Get(inOffset.Int64(), inSize.Int64()) 840 841 ret, returnGas, err := interpreter.evm.StaticCall(contract, toAddr, args, gas) 842 if err != nil { 843 stack.push(interpreter.intPool.getZero()) 844 } else { 845 stack.push(interpreter.intPool.get().SetUint64(1)) 846 } 847 if err == nil || err == errExecutionReverted { 848 memory.Set(retOffset.Uint64(), retSize.Uint64(), ret) 849 } 850 contract.Gas += returnGas 851 852 interpreter.intPool.put(addr, inOffset, inSize, retOffset, retSize) 853 return ret, nil 854 } 855 856 func opReturn(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 857 offset, size := stack.pop(), stack.pop() 858 ret := memory.GetPtr(offset.Int64(), size.Int64()) 859 860 interpreter.intPool.put(offset, size) 861 return ret, nil 862 } 863 864 func opRevert(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 865 offset, size := stack.pop(), stack.pop() 866 ret := memory.GetPtr(offset.Int64(), size.Int64()) 867 868 interpreter.intPool.put(offset, size) 869 return ret, nil 870 } 871 872 func opStop(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 873 return nil, nil 874 } 875 876 func opSuicide(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 877 balance := interpreter.evm.StateDB.GetBalance(contract.Address()) 878 interpreter.evm.StateDB.AddBalance(common.BigToAddress(stack.pop()), balance) 879 880 interpreter.evm.StateDB.Suicide(contract.Address()) 881 return nil, nil 882 } 883 884 // following functions are used by the instruction jump table 885 886 // make log instruction function 887 func makeLog(size int) executionFunc { 888 return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 889 topics := make([]common.Hash, size) 890 mStart, mSize := stack.pop(), stack.pop() 891 for i := 0; i < size; i++ { 892 topics[i] = common.BigToHash(stack.pop()) 893 } 894 895 d := memory.Get(mStart.Int64(), mSize.Int64()) 896 interpreter.evm.StateDB.AddLog(&types.Log{ 897 Address: contract.Address(), 898 Topics: topics, 899 Data: d, 900 // This is a non-consensus field, but assigned here because 901 // core/state doesn't know the current block number. 902 BlockNumber: interpreter.evm.BlockNumber.Uint64(), 903 }) 904 905 interpreter.intPool.put(mStart, mSize) 906 return nil, nil 907 } 908 } 909 910 // make push instruction function 911 func makePush(size uint64, pushByteSize int) executionFunc { 912 return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 913 codeLen := len(contract.Code) 914 915 startMin := codeLen 916 if int(*pc+1) < startMin { 917 startMin = int(*pc + 1) 918 } 919 920 endMin := codeLen 921 if startMin+pushByteSize < endMin { 922 endMin = startMin + pushByteSize 923 } 924 925 integer := interpreter.intPool.get() 926 stack.push(integer.SetBytes(common.RightPadBytes(contract.Code[startMin:endMin], pushByteSize))) 927 928 *pc += size 929 return nil, nil 930 } 931 } 932 933 // make dup instruction function 934 func makeDup(size int64) executionFunc { 935 return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 936 stack.dup(interpreter.intPool, int(size)) 937 return nil, nil 938 } 939 } 940 941 // make swap instruction function 942 func makeSwap(size int64) executionFunc { 943 // switch n + 1 otherwise n would be swapped with n 944 size++ 945 return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { 946 stack.swap(int(size)) 947 return nil, nil 948 } 949 }