grassrootseconomics/openethereum
5
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
7af953fd62
openethereum/ethcore/evm/src/instructions.rs
Wei Tang d04e5e49d0 Fix informant compile (#9571)
2018-09-17 16:16:49 +02:00

645 lines
26 KiB
Rust
Raw Blame History

// Copyright 2015-2018 Parity Technologies (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
//! VM Instructions list and utility functions
pub use self::Instruction::*;
macro_rules! enum_with_from_u8 {
(
$( #[$enum_attr:meta] )*
pub enum $name:ident {
$( $( #[$variant_attr:meta] )* $variant:ident = $discriminator:expr ),+,
}
) => {
$( #[$enum_attr] )*
pub enum $name {
$( $( #[$variant_attr] )* $variant = $discriminator ),+,
}
impl $name {
#[doc = "Convert from u8 to the given enum"]
pub fn from_u8(value: u8) -> Option<Self> {
match value {
$( $discriminator => Some($variant) ),+,
_ => None,
}
}
}
};
}
enum_with_from_u8! {
#[doc = "Virtual machine bytecode instruction."]
#[repr(u8)]
#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Debug, Hash)]
pub enum Instruction {
#[doc = "halts execution"]
STOP = 0x00,
#[doc = "addition operation"]
ADD = 0x01,
#[doc = "mulitplication operation"]
MUL = 0x02,
#[doc = "subtraction operation"]
SUB = 0x03,
#[doc = "integer division operation"]
DIV = 0x04,
#[doc = "signed integer division operation"]
SDIV = 0x05,
#[doc = "modulo remainder operation"]
MOD = 0x06,
#[doc = "signed modulo remainder operation"]
SMOD = 0x07,
#[doc = "unsigned modular addition"]
ADDMOD = 0x08,
#[doc = "unsigned modular multiplication"]
MULMOD = 0x09,
#[doc = "exponential operation"]
EXP = 0x0a,
#[doc = "extend length of signed integer"]
SIGNEXTEND = 0x0b,
#[doc = "less-than comparision"]
LT = 0x10,
#[doc = "greater-than comparision"]
GT = 0x11,
#[doc = "signed less-than comparision"]
SLT = 0x12,
#[doc = "signed greater-than comparision"]
SGT = 0x13,
#[doc = "equality comparision"]
EQ = 0x14,
#[doc = "simple not operator"]
ISZERO = 0x15,
#[doc = "bitwise AND operation"]
AND = 0x16,
#[doc = "bitwise OR operation"]
OR = 0x17,
#[doc = "bitwise XOR operation"]
XOR = 0x18,
#[doc = "bitwise NOT opertation"]
NOT = 0x19,
#[doc = "retrieve single byte from word"]
BYTE = 0x1a,
#[doc = "shift left operation"]
SHL = 0x1b,
#[doc = "logical shift right operation"]
SHR = 0x1c,
#[doc = "arithmetic shift right operation"]
SAR = 0x1d,
#[doc = "compute SHA3-256 hash"]
SHA3 = 0x20,
#[doc = "get address of currently executing account"]
ADDRESS = 0x30,
#[doc = "get balance of the given account"]
BALANCE = 0x31,
#[doc = "get execution origination address"]
ORIGIN = 0x32,
#[doc = "get caller address"]
CALLER = 0x33,
#[doc = "get deposited value by the instruction/transaction responsible for this execution"]
CALLVALUE = 0x34,
#[doc = "get input data of current environment"]
CALLDATALOAD = 0x35,
#[doc = "get size of input data in current environment"]
CALLDATASIZE = 0x36,
#[doc = "copy input data in current environment to memory"]
CALLDATACOPY = 0x37,
#[doc = "get size of code running in current environment"]
CODESIZE = 0x38,
#[doc = "copy code running in current environment to memory"]
CODECOPY = 0x39,
#[doc = "get price of gas in current environment"]
GASPRICE = 0x3a,
#[doc = "get external code size (from another contract)"]
EXTCODESIZE = 0x3b,
#[doc = "copy external code (from another contract)"]
EXTCODECOPY = 0x3c,
#[doc = "get the size of the return data buffer for the last call"]
RETURNDATASIZE = 0x3d,
#[doc = "copy return data buffer to memory"]
RETURNDATACOPY = 0x3e,
#[doc = "return the keccak256 hash of contract code"]
EXTCODEHASH = 0x3f,
#[doc = "get hash of most recent complete block"]
BLOCKHASH = 0x40,
#[doc = "get the block's coinbase address"]
COINBASE = 0x41,
#[doc = "get the block's timestamp"]
TIMESTAMP = 0x42,
#[doc = "get the block's number"]
NUMBER = 0x43,
#[doc = "get the block's difficulty"]
DIFFICULTY = 0x44,
#[doc = "get the block's gas limit"]
GASLIMIT = 0x45,
#[doc = "remove item from stack"]
POP = 0x50,
#[doc = "load word from memory"]
MLOAD = 0x51,
#[doc = "save word to memory"]
MSTORE = 0x52,
#[doc = "save byte to memory"]
MSTORE8 = 0x53,
#[doc = "load word from storage"]
SLOAD = 0x54,
#[doc = "save word to storage"]
SSTORE = 0x55,
#[doc = "alter the program counter"]
JUMP = 0x56,
#[doc = "conditionally alter the program counter"]
JUMPI = 0x57,
#[doc = "get the program counter"]
PC = 0x58,
#[doc = "get the size of active memory"]
MSIZE = 0x59,
#[doc = "get the amount of available gas"]
GAS = 0x5a,
#[doc = "set a potential jump destination"]
JUMPDEST = 0x5b,
#[doc = "place 1 byte item on stack"]
PUSH1 = 0x60,
#[doc = "place 2 byte item on stack"]
PUSH2 = 0x61,
#[doc = "place 3 byte item on stack"]
PUSH3 = 0x62,
#[doc = "place 4 byte item on stack"]
PUSH4 = 0x63,
#[doc = "place 5 byte item on stack"]
PUSH5 = 0x64,
#[doc = "place 6 byte item on stack"]
PUSH6 = 0x65,
#[doc = "place 7 byte item on stack"]
PUSH7 = 0x66,
#[doc = "place 8 byte item on stack"]
PUSH8 = 0x67,
#[doc = "place 9 byte item on stack"]
PUSH9 = 0x68,
#[doc = "place 10 byte item on stack"]
PUSH10 = 0x69,
#[doc = "place 11 byte item on stack"]
PUSH11 = 0x6a,
#[doc = "place 12 byte item on stack"]
PUSH12 = 0x6b,
#[doc = "place 13 byte item on stack"]
PUSH13 = 0x6c,
#[doc = "place 14 byte item on stack"]
PUSH14 = 0x6d,
#[doc = "place 15 byte item on stack"]
PUSH15 = 0x6e,
#[doc = "place 16 byte item on stack"]
PUSH16 = 0x6f,
#[doc = "place 17 byte item on stack"]
PUSH17 = 0x70,
#[doc = "place 18 byte item on stack"]
PUSH18 = 0x71,
#[doc = "place 19 byte item on stack"]
PUSH19 = 0x72,
#[doc = "place 20 byte item on stack"]
PUSH20 = 0x73,
#[doc = "place 21 byte item on stack"]
PUSH21 = 0x74,
#[doc = "place 22 byte item on stack"]
PUSH22 = 0x75,
#[doc = "place 23 byte item on stack"]
PUSH23 = 0x76,
#[doc = "place 24 byte item on stack"]
PUSH24 = 0x77,
#[doc = "place 25 byte item on stack"]
PUSH25 = 0x78,
#[doc = "place 26 byte item on stack"]
PUSH26 = 0x79,
#[doc = "place 27 byte item on stack"]
PUSH27 = 0x7a,
#[doc = "place 28 byte item on stack"]
PUSH28 = 0x7b,
#[doc = "place 29 byte item on stack"]
PUSH29 = 0x7c,
#[doc = "place 30 byte item on stack"]
PUSH30 = 0x7d,
#[doc = "place 31 byte item on stack"]
PUSH31 = 0x7e,
#[doc = "place 32 byte item on stack"]
PUSH32 = 0x7f,
#[doc = "copies the highest item in the stack to the top of the stack"]
DUP1 = 0x80,
#[doc = "copies the second highest item in the stack to the top of the stack"]
DUP2 = 0x81,
#[doc = "copies the third highest item in the stack to the top of the stack"]
DUP3 = 0x82,
#[doc = "copies the 4th highest item in the stack to the top of the stack"]
DUP4 = 0x83,
#[doc = "copies the 5th highest item in the stack to the top of the stack"]
DUP5 = 0x84,
#[doc = "copies the 6th highest item in the stack to the top of the stack"]
DUP6 = 0x85,
#[doc = "copies the 7th highest item in the stack to the top of the stack"]
DUP7 = 0x86,
#[doc = "copies the 8th highest item in the stack to the top of the stack"]
DUP8 = 0x87,
#[doc = "copies the 9th highest item in the stack to the top of the stack"]
DUP9 = 0x88,
#[doc = "copies the 10th highest item in the stack to the top of the stack"]
DUP10 = 0x89,
#[doc = "copies the 11th highest item in the stack to the top of the stack"]
DUP11 = 0x8a,
#[doc = "copies the 12th highest item in the stack to the top of the stack"]
DUP12 = 0x8b,
#[doc = "copies the 13th highest item in the stack to the top of the stack"]
DUP13 = 0x8c,
#[doc = "copies the 14th highest item in the stack to the top of the stack"]
DUP14 = 0x8d,
#[doc = "copies the 15th highest item in the stack to the top of the stack"]
DUP15 = 0x8e,
#[doc = "copies the 16th highest item in the stack to the top of the stack"]
DUP16 = 0x8f,
#[doc = "swaps the highest and second highest value on the stack"]
SWAP1 = 0x90,
#[doc = "swaps the highest and third highest value on the stack"]
SWAP2 = 0x91,
#[doc = "swaps the highest and 4th highest value on the stack"]
SWAP3 = 0x92,
#[doc = "swaps the highest and 5th highest value on the stack"]
SWAP4 = 0x93,
#[doc = "swaps the highest and 6th highest value on the stack"]
SWAP5 = 0x94,
#[doc = "swaps the highest and 7th highest value on the stack"]
SWAP6 = 0x95,
#[doc = "swaps the highest and 8th highest value on the stack"]
SWAP7 = 0x96,
#[doc = "swaps the highest and 9th highest value on the stack"]
SWAP8 = 0x97,
#[doc = "swaps the highest and 10th highest value on the stack"]
SWAP9 = 0x98,
#[doc = "swaps the highest and 11th highest value on the stack"]
SWAP10 = 0x99,
#[doc = "swaps the highest and 12th highest value on the stack"]
SWAP11 = 0x9a,
#[doc = "swaps the highest and 13th highest value on the stack"]
SWAP12 = 0x9b,
#[doc = "swaps the highest and 14th highest value on the stack"]
SWAP13 = 0x9c,
#[doc = "swaps the highest and 15th highest value on the stack"]
SWAP14 = 0x9d,
#[doc = "swaps the highest and 16th highest value on the stack"]
SWAP15 = 0x9e,
#[doc = "swaps the highest and 17th highest value on the stack"]
SWAP16 = 0x9f,
#[doc = "Makes a log entry, no topics."]
LOG0 = 0xa0,
#[doc = "Makes a log entry, 1 topic."]
LOG1 = 0xa1,
#[doc = "Makes a log entry, 2 topics."]
LOG2 = 0xa2,
#[doc = "Makes a log entry, 3 topics."]
LOG3 = 0xa3,
#[doc = "Makes a log entry, 4 topics."]
LOG4 = 0xa4,
#[doc = "create a new account with associated code"]
CREATE = 0xf0,
#[doc = "message-call into an account"]
CALL = 0xf1,
#[doc = "message-call with another account's code only"]
CALLCODE = 0xf2,
#[doc = "halt execution returning output data"]
RETURN = 0xf3,
#[doc = "like CALLCODE but keeps caller's value and sender"]
DELEGATECALL = 0xf4,
#[doc = "create a new account and set creation address to sha3(sender + sha3(init code)) % 2**160"]
CREATE2 = 0xf5,
#[doc = "stop execution and revert state changes. Return output data."]
REVERT = 0xfd,
#[doc = "like CALL but it does not take value, nor modify the state"]
STATICCALL = 0xfa,
#[doc = "halt execution and register account for later deletion"]
SUICIDE = 0xff,
}
}
impl Instruction {
/// Returns true if given instruction is `PUSHN` instruction.
pub fn is_push(&self) -> bool {
*self >= PUSH1 && *self <= PUSH32
}
/// Returns number of bytes to read for `PUSHN` instruction
/// PUSH1 -> 1
pub fn push_bytes(&self) -> Option<usize> {
if self.is_push() {
Some(((*self as u8) - (PUSH1 as u8) + 1) as usize)
} else {
None
}
}
/// Returns stack position of item to duplicate
/// DUP1 -> 0
pub fn dup_position(&self) -> Option<usize> {
if *self >= DUP1 && *self <= DUP16 {
Some(((*self as u8) - (DUP1 as u8)) as usize)
} else {
None
}
}
/// Returns stack position of item to SWAP top with
/// SWAP1 -> 1
pub fn swap_position(&self) -> Option<usize> {
if *self >= SWAP1 && *self <= SWAP16 {
Some(((*self as u8) - (SWAP1 as u8) + 1) as usize)
} else {
None
}
}
/// Returns number of topics to take from stack
/// LOG0 -> 0
pub fn log_topics(&self) -> Option<usize> {
if *self >= LOG0 && *self <= LOG4 {
Some(((*self as u8) - (LOG0 as u8)) as usize)
} else {
None
}
}
/// Returns the instruction info.
pub fn info(&self) -> &'static InstructionInfo {
INSTRUCTIONS[*self as usize].as_ref().expect("A instruction is defined in Instruction enum, but it is not found in InstructionInfo struct; this indicates a logic failure in the code.")
}
}
#[derive(PartialEq, Clone, Copy)]
pub enum GasPriceTier {
/// 0 Zero
Zero,
/// 2 Quick
Base,
/// 3 Fastest
VeryLow,
/// 5 Fast
Low,
/// 8 Mid
Mid,
/// 10 Slow
High,
/// 20 Ext
Ext,
/// Multiparam or otherwise special
Special,
}
impl GasPriceTier {
/// Returns the index in schedule for specific `GasPriceTier`
pub fn idx(&self) -> usize {
match self {
&GasPriceTier::Zero => 0,
&GasPriceTier::Base => 1,
&GasPriceTier::VeryLow => 2,
&GasPriceTier::Low => 3,
&GasPriceTier::Mid => 4,
&GasPriceTier::High => 5,
&GasPriceTier::Ext => 6,
&GasPriceTier::Special => 7,
}
}
}
/// EVM instruction information.
#[derive(Copy, Clone)]
pub struct InstructionInfo {
/// Mnemonic name.
pub name: &'static str,
/// Number of stack arguments.
pub args: usize,
/// Number of returned stack items.
pub ret: usize,
/// Gas price tier.
pub tier: GasPriceTier
}
impl InstructionInfo {
/// Create new instruction info.
pub fn new(name: &'static str, args: usize, ret: usize, tier: GasPriceTier) -> Self {
InstructionInfo {
name: name,
args: args,
ret: ret,
tier: tier
}
}
}
lazy_static! {
/// Static instruction table.
static ref INSTRUCTIONS: [Option<InstructionInfo>; 0x100] = {
let mut arr = [None; 0x100];
arr[STOP as usize] = Some(InstructionInfo::new("STOP", 0, 0, GasPriceTier::Zero));
arr[ADD as usize] = Some(InstructionInfo::new("ADD", 2, 1, GasPriceTier::VeryLow));
arr[SUB as usize] = Some(InstructionInfo::new("SUB", 2, 1, GasPriceTier::VeryLow));
arr[MUL as usize] = Some(InstructionInfo::new("MUL", 2, 1, GasPriceTier::Low));
arr[DIV as usize] = Some(InstructionInfo::new("DIV", 2, 1, GasPriceTier::Low));
arr[SDIV as usize] = Some(InstructionInfo::new("SDIV", 2, 1, GasPriceTier::Low));
arr[MOD as usize] = Some(InstructionInfo::new("MOD", 2, 1, GasPriceTier::Low));
arr[SMOD as usize] = Some(InstructionInfo::new("SMOD", 2, 1, GasPriceTier::Low));
arr[EXP as usize] = Some(InstructionInfo::new("EXP", 2, 1, GasPriceTier::Special));
arr[NOT as usize] = Some(InstructionInfo::new("NOT", 1, 1, GasPriceTier::VeryLow));
arr[LT as usize] = Some(InstructionInfo::new("LT", 2, 1, GasPriceTier::VeryLow));
arr[GT as usize] = Some(InstructionInfo::new("GT", 2, 1, GasPriceTier::VeryLow));
arr[SLT as usize] = Some(InstructionInfo::new("SLT", 2, 1, GasPriceTier::VeryLow));
arr[SGT as usize] = Some(InstructionInfo::new("SGT", 2, 1, GasPriceTier::VeryLow));
arr[EQ as usize] = Some(InstructionInfo::new("EQ", 2, 1, GasPriceTier::VeryLow));
arr[ISZERO as usize] = Some(InstructionInfo::new("ISZERO", 1, 1, GasPriceTier::VeryLow));
arr[AND as usize] = Some(InstructionInfo::new("AND", 2, 1, GasPriceTier::VeryLow));
arr[OR as usize] = Some(InstructionInfo::new("OR", 2, 1, GasPriceTier::VeryLow));
arr[XOR as usize] = Some(InstructionInfo::new("XOR", 2, 1, GasPriceTier::VeryLow));
arr[BYTE as usize] = Some(InstructionInfo::new("BYTE", 2, 1, GasPriceTier::VeryLow));
arr[SHL as usize] = Some(InstructionInfo::new("SHL", 2, 1, GasPriceTier::VeryLow));
arr[SHR as usize] = Some(InstructionInfo::new("SHR", 2, 1, GasPriceTier::VeryLow));
arr[SAR as usize] = Some(InstructionInfo::new("SAR", 2, 1, GasPriceTier::VeryLow));
arr[ADDMOD as usize] = Some(InstructionInfo::new("ADDMOD", 3, 1, GasPriceTier::Mid));
arr[MULMOD as usize] = Some(InstructionInfo::new("MULMOD", 3, 1, GasPriceTier::Mid));
arr[SIGNEXTEND as usize] = Some(InstructionInfo::new("SIGNEXTEND", 2, 1, GasPriceTier::Low));
arr[RETURNDATASIZE as usize] = Some(InstructionInfo::new("RETURNDATASIZE", 0, 1, GasPriceTier::Base));
arr[RETURNDATACOPY as usize] = Some(InstructionInfo::new("RETURNDATACOPY", 3, 0, GasPriceTier::VeryLow));
arr[SHA3 as usize] = Some(InstructionInfo::new("SHA3", 2, 1, GasPriceTier::Special));
arr[ADDRESS as usize] = Some(InstructionInfo::new("ADDRESS", 0, 1, GasPriceTier::Base));
arr[BALANCE as usize] = Some(InstructionInfo::new("BALANCE", 1, 1, GasPriceTier::Special));
arr[ORIGIN as usize] = Some(InstructionInfo::new("ORIGIN", 0, 1, GasPriceTier::Base));
arr[CALLER as usize] = Some(InstructionInfo::new("CALLER", 0, 1, GasPriceTier::Base));
arr[CALLVALUE as usize] = Some(InstructionInfo::new("CALLVALUE", 0, 1, GasPriceTier::Base));
arr[CALLDATALOAD as usize] = Some(InstructionInfo::new("CALLDATALOAD", 1, 1, GasPriceTier::VeryLow));
arr[CALLDATASIZE as usize] = Some(InstructionInfo::new("CALLDATASIZE", 0, 1, GasPriceTier::Base));
arr[CALLDATACOPY as usize] = Some(InstructionInfo::new("CALLDATACOPY", 3, 0, GasPriceTier::VeryLow));
arr[EXTCODEHASH as usize] = Some(InstructionInfo::new("EXTCODEHASH", 1, 1, GasPriceTier::Special));
arr[CODESIZE as usize] = Some(InstructionInfo::new("CODESIZE", 0, 1, GasPriceTier::Base));
arr[CODECOPY as usize] = Some(InstructionInfo::new("CODECOPY", 3, 0, GasPriceTier::VeryLow));
arr[GASPRICE as usize] = Some(InstructionInfo::new("GASPRICE", 0, 1, GasPriceTier::Base));
arr[EXTCODESIZE as usize] = Some(InstructionInfo::new("EXTCODESIZE", 1, 1, GasPriceTier::Special));
arr[EXTCODECOPY as usize] = Some(InstructionInfo::new("EXTCODECOPY", 4, 0, GasPriceTier::Special));
arr[BLOCKHASH as usize] = Some(InstructionInfo::new("BLOCKHASH", 1, 1, GasPriceTier::Ext));
arr[COINBASE as usize] = Some(InstructionInfo::new("COINBASE", 0, 1, GasPriceTier::Base));
arr[TIMESTAMP as usize] = Some(InstructionInfo::new("TIMESTAMP", 0, 1, GasPriceTier::Base));
arr[NUMBER as usize] = Some(InstructionInfo::new("NUMBER", 0, 1, GasPriceTier::Base));
arr[DIFFICULTY as usize] = Some(InstructionInfo::new("DIFFICULTY", 0, 1, GasPriceTier::Base));
arr[GASLIMIT as usize] = Some(InstructionInfo::new("GASLIMIT", 0, 1, GasPriceTier::Base));
arr[POP as usize] = Some(InstructionInfo::new("POP", 1, 0, GasPriceTier::Base));
arr[MLOAD as usize] = Some(InstructionInfo::new("MLOAD", 1, 1, GasPriceTier::VeryLow));
arr[MSTORE as usize] = Some(InstructionInfo::new("MSTORE", 2, 0, GasPriceTier::VeryLow));
arr[MSTORE8 as usize] = Some(InstructionInfo::new("MSTORE8", 2, 0, GasPriceTier::VeryLow));
arr[SLOAD as usize] = Some(InstructionInfo::new("SLOAD", 1, 1, GasPriceTier::Special));
arr[SSTORE as usize] = Some(InstructionInfo::new("SSTORE", 2, 0, GasPriceTier::Special));
arr[JUMP as usize] = Some(InstructionInfo::new("JUMP", 1, 0, GasPriceTier::Mid));
arr[JUMPI as usize] = Some(InstructionInfo::new("JUMPI", 2, 0, GasPriceTier::High));
arr[PC as usize] = Some(InstructionInfo::new("PC", 0, 1, GasPriceTier::Base));
arr[MSIZE as usize] = Some(InstructionInfo::new("MSIZE", 0, 1, GasPriceTier::Base));
arr[GAS as usize] = Some(InstructionInfo::new("GAS", 0, 1, GasPriceTier::Base));
arr[JUMPDEST as usize] = Some(InstructionInfo::new("JUMPDEST", 0, 0, GasPriceTier::Special));
arr[PUSH1 as usize] = Some(InstructionInfo::new("PUSH1", 0, 1, GasPriceTier::VeryLow));
arr[PUSH2 as usize] = Some(InstructionInfo::new("PUSH2", 0, 1, GasPriceTier::VeryLow));
arr[PUSH3 as usize] = Some(InstructionInfo::new("PUSH3", 0, 1, GasPriceTier::VeryLow));
arr[PUSH4 as usize] = Some(InstructionInfo::new("PUSH4", 0, 1, GasPriceTier::VeryLow));
arr[PUSH5 as usize] = Some(InstructionInfo::new("PUSH5", 0, 1, GasPriceTier::VeryLow));
arr[PUSH6 as usize] = Some(InstructionInfo::new("PUSH6", 0, 1, GasPriceTier::VeryLow));
arr[PUSH7 as usize] = Some(InstructionInfo::new("PUSH7", 0, 1, GasPriceTier::VeryLow));
arr[PUSH8 as usize] = Some(InstructionInfo::new("PUSH8", 0, 1, GasPriceTier::VeryLow));
arr[PUSH9 as usize] = Some(InstructionInfo::new("PUSH9", 0, 1, GasPriceTier::VeryLow));
arr[PUSH10 as usize] = Some(InstructionInfo::new("PUSH10", 0, 1, GasPriceTier::VeryLow));
arr[PUSH11 as usize] = Some(InstructionInfo::new("PUSH11", 0, 1, GasPriceTier::VeryLow));
arr[PUSH12 as usize] = Some(InstructionInfo::new("PUSH12", 0, 1, GasPriceTier::VeryLow));
arr[PUSH13 as usize] = Some(InstructionInfo::new("PUSH13", 0, 1, GasPriceTier::VeryLow));
arr[PUSH14 as usize] = Some(InstructionInfo::new("PUSH14", 0, 1, GasPriceTier::VeryLow));
arr[PUSH15 as usize] = Some(InstructionInfo::new("PUSH15", 0, 1, GasPriceTier::VeryLow));
arr[PUSH16 as usize] = Some(InstructionInfo::new("PUSH16", 0, 1, GasPriceTier::VeryLow));
arr[PUSH17 as usize] = Some(InstructionInfo::new("PUSH17", 0, 1, GasPriceTier::VeryLow));
arr[PUSH18 as usize] = Some(InstructionInfo::new("PUSH18", 0, 1, GasPriceTier::VeryLow));
arr[PUSH19 as usize] = Some(InstructionInfo::new("PUSH19", 0, 1, GasPriceTier::VeryLow));
arr[PUSH20 as usize] = Some(InstructionInfo::new("PUSH20", 0, 1, GasPriceTier::VeryLow));
arr[PUSH21 as usize] = Some(InstructionInfo::new("PUSH21", 0, 1, GasPriceTier::VeryLow));
arr[PUSH22 as usize] = Some(InstructionInfo::new("PUSH22", 0, 1, GasPriceTier::VeryLow));
arr[PUSH23 as usize] = Some(InstructionInfo::new("PUSH23", 0, 1, GasPriceTier::VeryLow));
arr[PUSH24 as usize] = Some(InstructionInfo::new("PUSH24", 0, 1, GasPriceTier::VeryLow));
arr[PUSH25 as usize] = Some(InstructionInfo::new("PUSH25", 0, 1, GasPriceTier::VeryLow));
arr[PUSH26 as usize] = Some(InstructionInfo::new("PUSH26", 0, 1, GasPriceTier::VeryLow));
arr[PUSH27 as usize] = Some(InstructionInfo::new("PUSH27", 0, 1, GasPriceTier::VeryLow));
arr[PUSH28 as usize] = Some(InstructionInfo::new("PUSH28", 0, 1, GasPriceTier::VeryLow));
arr[PUSH29 as usize] = Some(InstructionInfo::new("PUSH29", 0, 1, GasPriceTier::VeryLow));
arr[PUSH30 as usize] = Some(InstructionInfo::new("PUSH30", 0, 1, GasPriceTier::VeryLow));
arr[PUSH31 as usize] = Some(InstructionInfo::new("PUSH31", 0, 1, GasPriceTier::VeryLow));
arr[PUSH32 as usize] = Some(InstructionInfo::new("PUSH32", 0, 1, GasPriceTier::VeryLow));
arr[DUP1 as usize] = Some(InstructionInfo::new("DUP1", 1, 2, GasPriceTier::VeryLow));
arr[DUP2 as usize] = Some(InstructionInfo::new("DUP2", 2, 3, GasPriceTier::VeryLow));
arr[DUP3 as usize] = Some(InstructionInfo::new("DUP3", 3, 4, GasPriceTier::VeryLow));
arr[DUP4 as usize] = Some(InstructionInfo::new("DUP4", 4, 5, GasPriceTier::VeryLow));
arr[DUP5 as usize] = Some(InstructionInfo::new("DUP5", 5, 6, GasPriceTier::VeryLow));
arr[DUP6 as usize] = Some(InstructionInfo::new("DUP6", 6, 7, GasPriceTier::VeryLow));
arr[DUP7 as usize] = Some(InstructionInfo::new("DUP7", 7, 8, GasPriceTier::VeryLow));
arr[DUP8 as usize] = Some(InstructionInfo::new("DUP8", 8, 9, GasPriceTier::VeryLow));
arr[DUP9 as usize] = Some(InstructionInfo::new("DUP9", 9, 10, GasPriceTier::VeryLow));
arr[DUP10 as usize] = Some(InstructionInfo::new("DUP10", 10, 11, GasPriceTier::VeryLow));
arr[DUP11 as usize] = Some(InstructionInfo::new("DUP11", 11, 12, GasPriceTier::VeryLow));
arr[DUP12 as usize] = Some(InstructionInfo::new("DUP12", 12, 13, GasPriceTier::VeryLow));
arr[DUP13 as usize] = Some(InstructionInfo::new("DUP13", 13, 14, GasPriceTier::VeryLow));
arr[DUP14 as usize] = Some(InstructionInfo::new("DUP14", 14, 15, GasPriceTier::VeryLow));
arr[DUP15 as usize] = Some(InstructionInfo::new("DUP15", 15, 16, GasPriceTier::VeryLow));
arr[DUP16 as usize] = Some(InstructionInfo::new("DUP16", 16, 17, GasPriceTier::VeryLow));
arr[SWAP1 as usize] = Some(InstructionInfo::new("SWAP1", 2, 2, GasPriceTier::VeryLow));
arr[SWAP2 as usize] = Some(InstructionInfo::new("SWAP2", 3, 3, GasPriceTier::VeryLow));
arr[SWAP3 as usize] = Some(InstructionInfo::new("SWAP3", 4, 4, GasPriceTier::VeryLow));
arr[SWAP4 as usize] = Some(InstructionInfo::new("SWAP4", 5, 5, GasPriceTier::VeryLow));
arr[SWAP5 as usize] = Some(InstructionInfo::new("SWAP5", 6, 6, GasPriceTier::VeryLow));
arr[SWAP6 as usize] = Some(InstructionInfo::new("SWAP6", 7, 7, GasPriceTier::VeryLow));
arr[SWAP7 as usize] = Some(InstructionInfo::new("SWAP7", 8, 8, GasPriceTier::VeryLow));
arr[SWAP8 as usize] = Some(InstructionInfo::new("SWAP8", 9, 9, GasPriceTier::VeryLow));
arr[SWAP9 as usize] = Some(InstructionInfo::new("SWAP9", 10, 10, GasPriceTier::VeryLow));
arr[SWAP10 as usize] = Some(InstructionInfo::new("SWAP10", 11, 11, GasPriceTier::VeryLow));
arr[SWAP11 as usize] = Some(InstructionInfo::new("SWAP11", 12, 12, GasPriceTier::VeryLow));
arr[SWAP12 as usize] = Some(InstructionInfo::new("SWAP12", 13, 13, GasPriceTier::VeryLow));
arr[SWAP13 as usize] = Some(InstructionInfo::new("SWAP13", 14, 14, GasPriceTier::VeryLow));
arr[SWAP14 as usize] = Some(InstructionInfo::new("SWAP14", 15, 15, GasPriceTier::VeryLow));
arr[SWAP15 as usize] = Some(InstructionInfo::new("SWAP15", 16, 16, GasPriceTier::VeryLow));
arr[SWAP16 as usize] = Some(InstructionInfo::new("SWAP16", 17, 17, GasPriceTier::VeryLow));
arr[LOG0 as usize] = Some(InstructionInfo::new("LOG0", 2, 0, GasPriceTier::Special));
arr[LOG1 as usize] = Some(InstructionInfo::new("LOG1", 3, 0, GasPriceTier::Special));
arr[LOG2 as usize] = Some(InstructionInfo::new("LOG2", 4, 0, GasPriceTier::Special));
arr[LOG3 as usize] = Some(InstructionInfo::new("LOG3", 5, 0, GasPriceTier::Special));
arr[LOG4 as usize] = Some(InstructionInfo::new("LOG4", 6, 0, GasPriceTier::Special));
arr[CREATE as usize] = Some(InstructionInfo::new("CREATE", 3, 1, GasPriceTier::Special));
arr[CALL as usize] = Some(InstructionInfo::new("CALL", 7, 1, GasPriceTier::Special));
arr[CALLCODE as usize] = Some(InstructionInfo::new("CALLCODE", 7, 1, GasPriceTier::Special));
arr[RETURN as usize] = Some(InstructionInfo::new("RETURN", 2, 0, GasPriceTier::Zero));
arr[DELEGATECALL as usize] = Some(InstructionInfo::new("DELEGATECALL", 6, 1, GasPriceTier::Special));
arr[STATICCALL as usize] = Some(InstructionInfo::new("STATICCALL", 6, 1, GasPriceTier::Special));
arr[SUICIDE as usize] = Some(InstructionInfo::new("SUICIDE", 1, 0, GasPriceTier::Special));
arr[CREATE2 as usize] = Some(InstructionInfo::new("CREATE2", 4, 1, GasPriceTier::Special));
arr[REVERT as usize] = Some(InstructionInfo::new("REVERT", 2, 0, GasPriceTier::Zero));
arr
};
}
/// Maximal number of topics for log instructions
pub const MAX_NO_OF_TOPICS: usize = 4;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_is_push() {
assert!(PUSH1.is_push());
assert!(PUSH32.is_push());
assert!(!DUP1.is_push());
}
#[test]
fn test_get_push_bytes() {
assert_eq!(PUSH1.push_bytes(), Some(1));
assert_eq!(PUSH3.push_bytes(), Some(3));
assert_eq!(PUSH32.push_bytes(), Some(32));
}
#[test]
fn test_get_dup_position() {
assert_eq!(DUP1.dup_position(), Some(0));
assert_eq!(DUP5.dup_position(), Some(4));
assert_eq!(DUP10.dup_position(), Some(9));
}
#[test]
fn test_get_swap_position() {
assert_eq!(SWAP1.swap_position(), Some(1));
assert_eq!(SWAP5.swap_position(), Some(5));
assert_eq!(SWAP10.swap_position(), Some(10));
}
#[test]
fn test_get_log_topics() {
assert_eq!(LOG0.log_topics(), Some(0));
assert_eq!(LOG2.log_topics(), Some(2));
assert_eq!(LOG4.log_topics(), Some(4));
}
}
Reference in New Issue View Git Blame Copy Permalink