gitlab.com/flarenetwork/coreth@v0.1.1/core/vm/opcodes.go (about)

     1  // (c) 2019-2020, Ava Labs, Inc.
     2  //
     3  // This file is a derived work, based on the go-ethereum library whose original
     4  // notices appear below.
     5  //
     6  // It is distributed under a license compatible with the licensing terms of the
     7  // original code from which it is derived.
     8  //
     9  // Much love to the original authors for their work.
    10  // **********
    11  // Copyright 2014 The go-ethereum Authors
    12  // This file is part of the go-ethereum library.
    13  //
    14  // The go-ethereum library is free software: you can redistribute it and/or modify
    15  // it under the terms of the GNU Lesser General Public License as published by
    16  // the Free Software Foundation, either version 3 of the License, or
    17  // (at your option) any later version.
    18  //
    19  // The go-ethereum library is distributed in the hope that it will be useful,
    20  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    21  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    22  // GNU Lesser General Public License for more details.
    23  //
    24  // You should have received a copy of the GNU Lesser General Public License
    25  // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    26  
    27  package vm
    28  
    29  import (
    30  	"fmt"
    31  )
    32  
    33  // OpCode is an EVM opcode
    34  type OpCode byte
    35  
    36  // IsPush specifies if an opcode is a PUSH opcode.
    37  func (op OpCode) IsPush() bool {
    38  	switch op {
    39  	case PUSH1, PUSH2, PUSH3, PUSH4, PUSH5, PUSH6, PUSH7, PUSH8, PUSH9, PUSH10, PUSH11, PUSH12, PUSH13, PUSH14, PUSH15, PUSH16, PUSH17, PUSH18, PUSH19, PUSH20, PUSH21, PUSH22, PUSH23, PUSH24, PUSH25, PUSH26, PUSH27, PUSH28, PUSH29, PUSH30, PUSH31, PUSH32:
    40  		return true
    41  	}
    42  	return false
    43  }
    44  
    45  // IsStaticJump specifies if an opcode is JUMP.
    46  func (op OpCode) IsStaticJump() bool {
    47  	return op == JUMP
    48  }
    49  
    50  // 0x0 range - arithmetic ops.
    51  const (
    52  	STOP OpCode = iota
    53  	ADD
    54  	MUL
    55  	SUB
    56  	DIV
    57  	SDIV
    58  	MOD
    59  	SMOD
    60  	ADDMOD
    61  	MULMOD
    62  	EXP
    63  	SIGNEXTEND
    64  )
    65  
    66  // 0x10 range - comparison ops.
    67  const (
    68  	LT OpCode = iota + 0x10
    69  	GT
    70  	SLT
    71  	SGT
    72  	EQ
    73  	ISZERO
    74  	AND
    75  	OR
    76  	XOR
    77  	NOT
    78  	BYTE
    79  	SHL
    80  	SHR
    81  	SAR
    82  
    83  	SHA3 OpCode = 0x20
    84  )
    85  
    86  // 0x30 range - closure state.
    87  const (
    88  	ADDRESS OpCode = 0x30 + iota
    89  	BALANCE
    90  	ORIGIN
    91  	CALLER
    92  	CALLVALUE
    93  	CALLDATALOAD
    94  	CALLDATASIZE
    95  	CALLDATACOPY
    96  	CODESIZE
    97  	CODECOPY
    98  	GASPRICE
    99  	EXTCODESIZE
   100  	EXTCODECOPY
   101  	RETURNDATASIZE
   102  	RETURNDATACOPY
   103  	EXTCODEHASH
   104  )
   105  
   106  // 0x40 range - block operations.
   107  const (
   108  	BLOCKHASH OpCode = 0x40 + iota
   109  	COINBASE
   110  	TIMESTAMP
   111  	NUMBER
   112  	DIFFICULTY
   113  	GASLIMIT
   114  	CHAINID     OpCode = 0x46
   115  	SELFBALANCE OpCode = 0x47
   116  	BASEFEE     OpCode = 0x48
   117  )
   118  
   119  // 0x50 range - 'storage' and execution.
   120  const (
   121  	POP      OpCode = 0x50
   122  	MLOAD    OpCode = 0x51
   123  	MSTORE   OpCode = 0x52
   124  	MSTORE8  OpCode = 0x53
   125  	SLOAD    OpCode = 0x54
   126  	SSTORE   OpCode = 0x55
   127  	JUMP     OpCode = 0x56
   128  	JUMPI    OpCode = 0x57
   129  	PC       OpCode = 0x58
   130  	MSIZE    OpCode = 0x59
   131  	GAS      OpCode = 0x5a
   132  	JUMPDEST OpCode = 0x5b
   133  )
   134  
   135  // 0x60 range.
   136  const (
   137  	PUSH1 OpCode = 0x60 + iota
   138  	PUSH2
   139  	PUSH3
   140  	PUSH4
   141  	PUSH5
   142  	PUSH6
   143  	PUSH7
   144  	PUSH8
   145  	PUSH9
   146  	PUSH10
   147  	PUSH11
   148  	PUSH12
   149  	PUSH13
   150  	PUSH14
   151  	PUSH15
   152  	PUSH16
   153  	PUSH17
   154  	PUSH18
   155  	PUSH19
   156  	PUSH20
   157  	PUSH21
   158  	PUSH22
   159  	PUSH23
   160  	PUSH24
   161  	PUSH25
   162  	PUSH26
   163  	PUSH27
   164  	PUSH28
   165  	PUSH29
   166  	PUSH30
   167  	PUSH31
   168  	PUSH32
   169  	DUP1
   170  	DUP2
   171  	DUP3
   172  	DUP4
   173  	DUP5
   174  	DUP6
   175  	DUP7
   176  	DUP8
   177  	DUP9
   178  	DUP10
   179  	DUP11
   180  	DUP12
   181  	DUP13
   182  	DUP14
   183  	DUP15
   184  	DUP16
   185  	SWAP1
   186  	SWAP2
   187  	SWAP3
   188  	SWAP4
   189  	SWAP5
   190  	SWAP6
   191  	SWAP7
   192  	SWAP8
   193  	SWAP9
   194  	SWAP10
   195  	SWAP11
   196  	SWAP12
   197  	SWAP13
   198  	SWAP14
   199  	SWAP15
   200  	SWAP16
   201  )
   202  
   203  // 0xa0 range - logging ops.
   204  const (
   205  	LOG0 OpCode = 0xa0 + iota
   206  	LOG1
   207  	LOG2
   208  	LOG3
   209  	LOG4
   210  )
   211  
   212  // unofficial opcodes used for parsing.
   213  const (
   214  	PUSH OpCode = 0xb0 + iota
   215  	DUP
   216  	SWAP
   217  )
   218  
   219  const (
   220  	BALANCEMC = 0xcd
   221  	CALLEX    = 0xcf
   222  )
   223  
   224  // 0xf0 range - closures.
   225  const (
   226  	CREATE OpCode = 0xf0 + iota
   227  	CALL
   228  	CALLCODE
   229  	RETURN
   230  	DELEGATECALL
   231  	CREATE2
   232  	STATICCALL   OpCode = 0xfa
   233  	REVERT       OpCode = 0xfd
   234  	SELFDESTRUCT OpCode = 0xff
   235  )
   236  
   237  // Since the opcodes aren't all in order we can't use a regular slice.
   238  var opCodeToString = map[OpCode]string{
   239  	// 0x0 range - arithmetic ops.
   240  	STOP:       "STOP",
   241  	ADD:        "ADD",
   242  	MUL:        "MUL",
   243  	SUB:        "SUB",
   244  	DIV:        "DIV",
   245  	SDIV:       "SDIV",
   246  	MOD:        "MOD",
   247  	SMOD:       "SMOD",
   248  	EXP:        "EXP",
   249  	NOT:        "NOT",
   250  	LT:         "LT",
   251  	GT:         "GT",
   252  	SLT:        "SLT",
   253  	SGT:        "SGT",
   254  	EQ:         "EQ",
   255  	ISZERO:     "ISZERO",
   256  	SIGNEXTEND: "SIGNEXTEND",
   257  
   258  	// 0x10 range - bit ops.
   259  	AND:    "AND",
   260  	OR:     "OR",
   261  	XOR:    "XOR",
   262  	BYTE:   "BYTE",
   263  	SHL:    "SHL",
   264  	SHR:    "SHR",
   265  	SAR:    "SAR",
   266  	ADDMOD: "ADDMOD",
   267  	MULMOD: "MULMOD",
   268  
   269  	// 0x20 range - crypto.
   270  	SHA3: "SHA3",
   271  
   272  	// 0x30 range - closure state.
   273  	ADDRESS:        "ADDRESS",
   274  	BALANCE:        "BALANCE",
   275  	BALANCEMC:      "BALANCEMC",
   276  	ORIGIN:         "ORIGIN",
   277  	CALLER:         "CALLER",
   278  	CALLVALUE:      "CALLVALUE",
   279  	CALLDATALOAD:   "CALLDATALOAD",
   280  	CALLDATASIZE:   "CALLDATASIZE",
   281  	CALLDATACOPY:   "CALLDATACOPY",
   282  	CODESIZE:       "CODESIZE",
   283  	CODECOPY:       "CODECOPY",
   284  	GASPRICE:       "GASPRICE",
   285  	EXTCODESIZE:    "EXTCODESIZE",
   286  	EXTCODECOPY:    "EXTCODECOPY",
   287  	RETURNDATASIZE: "RETURNDATASIZE",
   288  	RETURNDATACOPY: "RETURNDATACOPY",
   289  	EXTCODEHASH:    "EXTCODEHASH",
   290  
   291  	// 0x40 range - block operations.
   292  	BLOCKHASH:   "BLOCKHASH",
   293  	COINBASE:    "COINBASE",
   294  	TIMESTAMP:   "TIMESTAMP",
   295  	NUMBER:      "NUMBER",
   296  	DIFFICULTY:  "DIFFICULTY",
   297  	GASLIMIT:    "GASLIMIT",
   298  	CHAINID:     "CHAINID",
   299  	SELFBALANCE: "SELFBALANCE",
   300  	BASEFEE:     "BASEFEE",
   301  
   302  	// 0x50 range - 'storage' and execution.
   303  	POP: "POP",
   304  	//DUP:     "DUP",
   305  	//SWAP:    "SWAP",
   306  	MLOAD:    "MLOAD",
   307  	MSTORE:   "MSTORE",
   308  	MSTORE8:  "MSTORE8",
   309  	SLOAD:    "SLOAD",
   310  	SSTORE:   "SSTORE",
   311  	JUMP:     "JUMP",
   312  	JUMPI:    "JUMPI",
   313  	PC:       "PC",
   314  	MSIZE:    "MSIZE",
   315  	GAS:      "GAS",
   316  	JUMPDEST: "JUMPDEST",
   317  
   318  	// 0x60 range - push.
   319  	PUSH1:  "PUSH1",
   320  	PUSH2:  "PUSH2",
   321  	PUSH3:  "PUSH3",
   322  	PUSH4:  "PUSH4",
   323  	PUSH5:  "PUSH5",
   324  	PUSH6:  "PUSH6",
   325  	PUSH7:  "PUSH7",
   326  	PUSH8:  "PUSH8",
   327  	PUSH9:  "PUSH9",
   328  	PUSH10: "PUSH10",
   329  	PUSH11: "PUSH11",
   330  	PUSH12: "PUSH12",
   331  	PUSH13: "PUSH13",
   332  	PUSH14: "PUSH14",
   333  	PUSH15: "PUSH15",
   334  	PUSH16: "PUSH16",
   335  	PUSH17: "PUSH17",
   336  	PUSH18: "PUSH18",
   337  	PUSH19: "PUSH19",
   338  	PUSH20: "PUSH20",
   339  	PUSH21: "PUSH21",
   340  	PUSH22: "PUSH22",
   341  	PUSH23: "PUSH23",
   342  	PUSH24: "PUSH24",
   343  	PUSH25: "PUSH25",
   344  	PUSH26: "PUSH26",
   345  	PUSH27: "PUSH27",
   346  	PUSH28: "PUSH28",
   347  	PUSH29: "PUSH29",
   348  	PUSH30: "PUSH30",
   349  	PUSH31: "PUSH31",
   350  	PUSH32: "PUSH32",
   351  
   352  	DUP1:  "DUP1",
   353  	DUP2:  "DUP2",
   354  	DUP3:  "DUP3",
   355  	DUP4:  "DUP4",
   356  	DUP5:  "DUP5",
   357  	DUP6:  "DUP6",
   358  	DUP7:  "DUP7",
   359  	DUP8:  "DUP8",
   360  	DUP9:  "DUP9",
   361  	DUP10: "DUP10",
   362  	DUP11: "DUP11",
   363  	DUP12: "DUP12",
   364  	DUP13: "DUP13",
   365  	DUP14: "DUP14",
   366  	DUP15: "DUP15",
   367  	DUP16: "DUP16",
   368  
   369  	SWAP1:  "SWAP1",
   370  	SWAP2:  "SWAP2",
   371  	SWAP3:  "SWAP3",
   372  	SWAP4:  "SWAP4",
   373  	SWAP5:  "SWAP5",
   374  	SWAP6:  "SWAP6",
   375  	SWAP7:  "SWAP7",
   376  	SWAP8:  "SWAP8",
   377  	SWAP9:  "SWAP9",
   378  	SWAP10: "SWAP10",
   379  	SWAP11: "SWAP11",
   380  	SWAP12: "SWAP12",
   381  	SWAP13: "SWAP13",
   382  	SWAP14: "SWAP14",
   383  	SWAP15: "SWAP15",
   384  	SWAP16: "SWAP16",
   385  	LOG0:   "LOG0",
   386  	LOG1:   "LOG1",
   387  	LOG2:   "LOG2",
   388  	LOG3:   "LOG3",
   389  	LOG4:   "LOG4",
   390  
   391  	// 0xf0 range.
   392  	CREATE:       "CREATE",
   393  	CALL:         "CALL",
   394  	CALLEX:       "CALLEX",
   395  	RETURN:       "RETURN",
   396  	CALLCODE:     "CALLCODE",
   397  	DELEGATECALL: "DELEGATECALL",
   398  	CREATE2:      "CREATE2",
   399  	STATICCALL:   "STATICCALL",
   400  	REVERT:       "REVERT",
   401  	SELFDESTRUCT: "SELFDESTRUCT",
   402  
   403  	PUSH: "PUSH",
   404  	DUP:  "DUP",
   405  	SWAP: "SWAP",
   406  }
   407  
   408  func (op OpCode) String() string {
   409  	str := opCodeToString[op]
   410  	if len(str) == 0 {
   411  		return fmt.Sprintf("opcode 0x%x not defined", int(op))
   412  	}
   413  
   414  	return str
   415  }
   416  
   417  var stringToOp = map[string]OpCode{
   418  	"STOP":           STOP,
   419  	"ADD":            ADD,
   420  	"MUL":            MUL,
   421  	"SUB":            SUB,
   422  	"DIV":            DIV,
   423  	"SDIV":           SDIV,
   424  	"MOD":            MOD,
   425  	"SMOD":           SMOD,
   426  	"EXP":            EXP,
   427  	"NOT":            NOT,
   428  	"LT":             LT,
   429  	"GT":             GT,
   430  	"SLT":            SLT,
   431  	"SGT":            SGT,
   432  	"EQ":             EQ,
   433  	"ISZERO":         ISZERO,
   434  	"SIGNEXTEND":     SIGNEXTEND,
   435  	"AND":            AND,
   436  	"OR":             OR,
   437  	"XOR":            XOR,
   438  	"BYTE":           BYTE,
   439  	"SHL":            SHL,
   440  	"SHR":            SHR,
   441  	"SAR":            SAR,
   442  	"ADDMOD":         ADDMOD,
   443  	"MULMOD":         MULMOD,
   444  	"SHA3":           SHA3,
   445  	"ADDRESS":        ADDRESS,
   446  	"BALANCE":        BALANCE,
   447  	"BALANCEMC":      BALANCEMC,
   448  	"ORIGIN":         ORIGIN,
   449  	"CALLER":         CALLER,
   450  	"CALLVALUE":      CALLVALUE,
   451  	"CALLDATALOAD":   CALLDATALOAD,
   452  	"CALLDATASIZE":   CALLDATASIZE,
   453  	"CALLDATACOPY":   CALLDATACOPY,
   454  	"CHAINID":        CHAINID,
   455  	"BASEFEE":        BASEFEE,
   456  	"DELEGATECALL":   DELEGATECALL,
   457  	"STATICCALL":     STATICCALL,
   458  	"CODESIZE":       CODESIZE,
   459  	"CODECOPY":       CODECOPY,
   460  	"GASPRICE":       GASPRICE,
   461  	"EXTCODESIZE":    EXTCODESIZE,
   462  	"EXTCODECOPY":    EXTCODECOPY,
   463  	"RETURNDATASIZE": RETURNDATASIZE,
   464  	"RETURNDATACOPY": RETURNDATACOPY,
   465  	"EXTCODEHASH":    EXTCODEHASH,
   466  	"BLOCKHASH":      BLOCKHASH,
   467  	"COINBASE":       COINBASE,
   468  	"TIMESTAMP":      TIMESTAMP,
   469  	"NUMBER":         NUMBER,
   470  	"DIFFICULTY":     DIFFICULTY,
   471  	"GASLIMIT":       GASLIMIT,
   472  	"SELFBALANCE":    SELFBALANCE,
   473  	"POP":            POP,
   474  	"MLOAD":          MLOAD,
   475  	"MSTORE":         MSTORE,
   476  	"MSTORE8":        MSTORE8,
   477  	"SLOAD":          SLOAD,
   478  	"SSTORE":         SSTORE,
   479  	"JUMP":           JUMP,
   480  	"JUMPI":          JUMPI,
   481  	"PC":             PC,
   482  	"MSIZE":          MSIZE,
   483  	"GAS":            GAS,
   484  	"JUMPDEST":       JUMPDEST,
   485  	"PUSH1":          PUSH1,
   486  	"PUSH2":          PUSH2,
   487  	"PUSH3":          PUSH3,
   488  	"PUSH4":          PUSH4,
   489  	"PUSH5":          PUSH5,
   490  	"PUSH6":          PUSH6,
   491  	"PUSH7":          PUSH7,
   492  	"PUSH8":          PUSH8,
   493  	"PUSH9":          PUSH9,
   494  	"PUSH10":         PUSH10,
   495  	"PUSH11":         PUSH11,
   496  	"PUSH12":         PUSH12,
   497  	"PUSH13":         PUSH13,
   498  	"PUSH14":         PUSH14,
   499  	"PUSH15":         PUSH15,
   500  	"PUSH16":         PUSH16,
   501  	"PUSH17":         PUSH17,
   502  	"PUSH18":         PUSH18,
   503  	"PUSH19":         PUSH19,
   504  	"PUSH20":         PUSH20,
   505  	"PUSH21":         PUSH21,
   506  	"PUSH22":         PUSH22,
   507  	"PUSH23":         PUSH23,
   508  	"PUSH24":         PUSH24,
   509  	"PUSH25":         PUSH25,
   510  	"PUSH26":         PUSH26,
   511  	"PUSH27":         PUSH27,
   512  	"PUSH28":         PUSH28,
   513  	"PUSH29":         PUSH29,
   514  	"PUSH30":         PUSH30,
   515  	"PUSH31":         PUSH31,
   516  	"PUSH32":         PUSH32,
   517  	"DUP1":           DUP1,
   518  	"DUP2":           DUP2,
   519  	"DUP3":           DUP3,
   520  	"DUP4":           DUP4,
   521  	"DUP5":           DUP5,
   522  	"DUP6":           DUP6,
   523  	"DUP7":           DUP7,
   524  	"DUP8":           DUP8,
   525  	"DUP9":           DUP9,
   526  	"DUP10":          DUP10,
   527  	"DUP11":          DUP11,
   528  	"DUP12":          DUP12,
   529  	"DUP13":          DUP13,
   530  	"DUP14":          DUP14,
   531  	"DUP15":          DUP15,
   532  	"DUP16":          DUP16,
   533  	"SWAP1":          SWAP1,
   534  	"SWAP2":          SWAP2,
   535  	"SWAP3":          SWAP3,
   536  	"SWAP4":          SWAP4,
   537  	"SWAP5":          SWAP5,
   538  	"SWAP6":          SWAP6,
   539  	"SWAP7":          SWAP7,
   540  	"SWAP8":          SWAP8,
   541  	"SWAP9":          SWAP9,
   542  	"SWAP10":         SWAP10,
   543  	"SWAP11":         SWAP11,
   544  	"SWAP12":         SWAP12,
   545  	"SWAP13":         SWAP13,
   546  	"SWAP14":         SWAP14,
   547  	"SWAP15":         SWAP15,
   548  	"SWAP16":         SWAP16,
   549  	"LOG0":           LOG0,
   550  	"LOG1":           LOG1,
   551  	"LOG2":           LOG2,
   552  	"LOG3":           LOG3,
   553  	"LOG4":           LOG4,
   554  	"CREATE":         CREATE,
   555  	"CREATE2":        CREATE2,
   556  	"CALL":           CALL,
   557  	"CALLEX":         CALLEX,
   558  	"RETURN":         RETURN,
   559  	"CALLCODE":       CALLCODE,
   560  	"REVERT":         REVERT,
   561  	"SELFDESTRUCT":   SELFDESTRUCT,
   562  }
   563  
   564  // StringToOp finds the opcode whose name is stored in `str`.
   565  func StringToOp(str string) OpCode {
   566  	return stringToOp[str]
   567  }