ethereumvm 0.11.0

EthereumVM - a Portable Blockchain Virtual Machine
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

//! Bitwise instructions

use bigint::{Sign, M256, MI256};

use super::State;
use crate::{Memory, Patch};

pub fn iszero<M: Memory, P: Patch>(state: &mut State<M, P>) {
    pop!(state, op1);

    if op1 == M256::zero() {
        push!(state, M256::from(1u64));
    } else {
        push!(state, M256::zero());
    }
}

pub fn not<M: Memory, P: Patch>(state: &mut State<M, P>) {
    pop!(state, op1);
    push!(state, !op1);
}

pub fn byte<M: Memory, P: Patch>(state: &mut State<M, P>) {
    pop!(state, op1, op2);

    let mut ret = M256::zero();

    for i in 0..256 {
        if i < 8 && op1 < 32.into() {
            let o: usize = op1.as_usize();
            let t = 255 - (7 - i + 8 * o);
            let bit_mask = M256::one() << t;
            let value = (op2 & bit_mask) >> t;
            ret = ret + (value << i);
        }
    }

    push!(state, ret);
}

pub fn shl<M: Memory, P: Patch>(state: &mut State<M, P>) {
    pop!(state, shift, value);

    let result = if value == M256::zero() || shift >= M256::from(256) {
        M256::zero()
    } else {
        let shift: u64 = shift.into();
        value << shift as usize
    };

    push!(state, result);
}

pub fn shr<M: Memory, P: Patch>(state: &mut State<M, P>) {
    pop!(state, shift, value);

    let result = if value == M256::zero() || shift >= M256::from(256) {
        M256::zero()
    } else {
        let shift: u64 = shift.into();
        value >> shift as usize
    };

    push!(state, result);
}

pub fn sar<M: Memory, P: Patch>(state: &mut State<M, P>) {
    pop!(state, shift, value);
    let value = MI256::from(value);

    let result = if value == MI256::zero() || shift >= M256::from(256) {
        let MI256(sign, _) = value;
        match sign {
            // value is 0 or >=1, pushing 0
            Sign::Plus | Sign::NoSign => M256::zero(),
            // value is <0, pushing -1
            Sign::Minus => MI256(Sign::Minus, M256::one()).into(),
        }
    } else {
        let shift: u64 = shift.into();

        match value.0 {
            Sign::Plus | Sign::NoSign => value.1 >> shift as usize,
            Sign::Minus => {
                let shifted = ((value.1 - M256::one()) >> shift as usize) + M256::one();
                MI256(Sign::Minus, shifted).into()
            }
        }
    };

    push!(state, result);
}