github.com/ontio/ontology@v1.14.4/vm/evm/opcodes.go (about)

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