github.com/gobitfly/go-ethereum@v1.8.12/core/vm/opcodes.go (about)

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