1#[cfg(feature = "parse")]
4pub mod parse;
5
6use core::{fmt, ptr::NonNull};
7
8#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
13#[repr(transparent)]
14pub struct OpCode(u8);
15
16impl fmt::Display for OpCode {
17 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
19 let n = self.get();
20 if let Some(val) = OPCODE_INFO[n as usize] {
21 f.write_str(val.name())
22 } else {
23 write!(f, "UNKNOWN(0x{n:02X})")
24 }
25 }
26}
27
28impl OpCode {
29 #[inline]
33 pub const fn new(opcode: u8) -> Option<Self> {
34 match OPCODE_INFO[opcode as usize] {
35 Some(_) => Some(Self(opcode)),
36 None => None,
37 }
38 }
39
40 #[inline]
42 pub const fn is_jumpdest(&self) -> bool {
43 self.0 == JUMPDEST
44 }
45
46 #[inline]
48 pub const fn is_jumpdest_by_op(opcode: u8) -> bool {
49 if let Some(opcode) = Self::new(opcode) {
50 opcode.is_jumpdest()
51 } else {
52 false
53 }
54 }
55
56 #[inline]
58 pub const fn is_jump(self) -> bool {
59 self.0 == JUMP
60 }
61
62 #[inline]
64 pub const fn is_jump_by_op(opcode: u8) -> bool {
65 if let Some(opcode) = Self::new(opcode) {
66 opcode.is_jump()
67 } else {
68 false
69 }
70 }
71
72 #[inline]
74 pub const fn is_push(self) -> bool {
75 self.0 >= PUSH1 && self.0 <= PUSH32
76 }
77
78 #[inline]
80 pub fn is_push_by_op(opcode: u8) -> bool {
81 if let Some(opcode) = Self::new(opcode) {
82 opcode.is_push()
83 } else {
84 false
85 }
86 }
87
88 #[inline]
95 pub unsafe fn new_unchecked(opcode: u8) -> Self {
96 Self(opcode)
97 }
98
99 #[doc(alias = "name")]
101 #[inline]
102 pub const fn as_str(self) -> &'static str {
103 self.info().name()
104 }
105
106 #[inline]
108 pub const fn name_by_op(opcode: u8) -> &'static str {
109 if let Some(opcode) = Self::new(opcode) {
110 opcode.as_str()
111 } else {
112 "Unknown"
113 }
114 }
115
116 #[inline]
118 pub const fn inputs(&self) -> u8 {
119 self.info().inputs()
120 }
121
122 #[inline]
124 pub const fn outputs(&self) -> u8 {
125 self.info().outputs()
126 }
127
128 #[inline]
130 pub const fn io_diff(&self) -> i16 {
131 self.info().io_diff()
132 }
133
134 #[inline]
137 pub const fn info_by_op(opcode: u8) -> Option<OpCodeInfo> {
138 if let Some(opcode) = Self::new(opcode) {
139 Some(opcode.info())
140 } else {
141 None
142 }
143 }
144
145 #[inline]
147 pub const fn as_usize(&self) -> usize {
148 self.0 as usize
149 }
150
151 #[inline]
153 pub const fn info(&self) -> OpCodeInfo {
154 if let Some(t) = OPCODE_INFO[self.0 as usize] {
155 t
156 } else {
157 panic!("opcode not found")
158 }
159 }
160
161 pub const fn input_output(&self) -> (u8, u8) {
165 let info = self.info();
166 (info.inputs, info.outputs)
167 }
168
169 #[inline]
171 pub const fn get(self) -> u8 {
172 self.0
173 }
174
175 #[inline]
181 pub const fn modifies_memory(&self) -> bool {
182 matches!(
183 *self,
184 OpCode::EXTCODECOPY
185 | OpCode::MLOAD
186 | OpCode::MSTORE
187 | OpCode::MSTORE8
188 | OpCode::MCOPY
189 | OpCode::CODECOPY
190 | OpCode::CALLDATACOPY
191 | OpCode::RETURNDATACOPY
192 | OpCode::CALL
193 | OpCode::CALLCODE
194 | OpCode::DELEGATECALL
195 | OpCode::STATICCALL
196 | OpCode::DATACOPY
197 | OpCode::EOFCREATE
198 | OpCode::RETURNCONTRACT
199 | OpCode::EXTCALL
200 | OpCode::EXTDELEGATECALL
201 | OpCode::EXTSTATICCALL
202 )
203 }
204}
205
206#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
208pub struct OpCodeInfo {
209 name_ptr: NonNull<u8>,
214 name_len: u8,
215 inputs: u8,
217 outputs: u8,
219 immediate_size: u8,
224 not_eof: bool,
228 terminating: bool,
230}
231
232impl fmt::Debug for OpCodeInfo {
233 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
234 f.debug_struct("OpCodeInfo")
235 .field("name", &self.name())
236 .field("inputs", &self.inputs())
237 .field("outputs", &self.outputs())
238 .field("not_eof", &self.is_disabled_in_eof())
239 .field("terminating", &self.is_terminating())
240 .field("immediate_size", &self.immediate_size())
241 .finish()
242 }
243}
244
245impl OpCodeInfo {
246 pub const fn new(name: &'static str) -> Self {
248 assert!(name.len() < 256, "opcode name is too long");
249 Self {
250 name_ptr: unsafe { NonNull::new_unchecked(name.as_ptr().cast_mut()) },
251 name_len: name.len() as u8,
252 inputs: 0,
253 outputs: 0,
254 not_eof: false,
255 terminating: false,
256 immediate_size: 0,
257 }
258 }
259
260 #[inline]
262 pub const fn name(&self) -> &'static str {
263 unsafe {
265 let slice = std::slice::from_raw_parts(self.name_ptr.as_ptr(), self.name_len as usize);
266 core::str::from_utf8_unchecked(slice)
267 }
268 }
269
270 #[inline]
272 pub const fn io_diff(&self) -> i16 {
273 self.outputs as i16 - self.inputs as i16
274 }
275
276 #[inline]
278 pub const fn inputs(&self) -> u8 {
279 self.inputs
280 }
281
282 #[inline]
284 pub const fn outputs(&self) -> u8 {
285 self.outputs
286 }
287
288 #[inline]
290 pub const fn is_disabled_in_eof(&self) -> bool {
291 self.not_eof
292 }
293
294 #[inline]
296 pub const fn is_terminating(&self) -> bool {
297 self.terminating
298 }
299
300 #[inline]
302 pub const fn immediate_size(&self) -> u8 {
303 self.immediate_size
304 }
305}
306
307#[inline]
309pub const fn not_eof(mut op: OpCodeInfo) -> OpCodeInfo {
310 op.not_eof = true;
311 op
312}
313
314#[inline]
319pub const fn immediate_size(mut op: OpCodeInfo, n: u8) -> OpCodeInfo {
320 op.immediate_size = n;
321 op
322}
323
324#[inline]
326pub const fn terminating(mut op: OpCodeInfo) -> OpCodeInfo {
327 op.terminating = true;
328 op
329}
330
331#[inline]
333pub const fn stack_io(mut op: OpCodeInfo, inputs: u8, outputs: u8) -> OpCodeInfo {
334 op.inputs = inputs;
335 op.outputs = outputs;
336 op
337}
338
339pub const NOP: u8 = JUMPDEST;
341
342macro_rules! opcodes {
346 ($($val:literal => $name:ident => $($modifier:ident $(( $($modifier_arg:expr),* ))?),*);* $(;)?) => {
347 $(
349 #[doc = concat!("The `", stringify!($val), "` (\"", stringify!($name),"\") opcode.")]
350 pub const $name: u8 = $val;
351 )*
352 impl OpCode {$(
353 #[doc = concat!("The `", stringify!($val), "` (\"", stringify!($name),"\") opcode.")]
354 pub const $name: Self = Self($val);
355 )*}
356
357 pub const OPCODE_INFO: [Option<OpCodeInfo>; 256] = {
359 let mut map = [None; 256];
360 let mut prev: u8 = 0;
361 $(
362 let val: u8 = $val;
363 assert!(val == 0 || val > prev, "opcodes must be sorted in ascending order");
364 prev = val;
365 let info = OpCodeInfo::new(stringify!($name));
366 $(
367 let info = $modifier(info, $($($modifier_arg),*)?);
368 )*
369 map[$val] = Some(info);
370 )*
371 let _ = prev;
372 map
373 };
374
375
376 #[cfg(feature = "parse")]
378 pub(crate) static NAME_TO_OPCODE: phf::Map<&'static str, OpCode> = stringify_with_cb! { phf_map_cb; $($name)* };
379 };
380}
381
382#[cfg(feature = "parse")]
384macro_rules! phf_map_cb {
385 ($(#[doc = $s:literal] $id:ident)*) => {
386 phf::phf_map! {
387 $($s => OpCode::$id),*
388 }
389 };
390}
391
392#[cfg(feature = "parse")]
396macro_rules! stringify_with_cb {
397 ($callback:ident; $($id:ident)*) => { paste::paste! {
398 $callback! { $(#[doc = "" $id ""] $id)* }
399 }};
400}
401
402opcodes! {
407 0x00 => STOP => stack_io(0, 0), terminating;
408 0x01 => ADD => stack_io(2, 1);
409 0x02 => MUL => stack_io(2, 1);
410 0x03 => SUB => stack_io(2, 1);
411 0x04 => DIV => stack_io(2, 1);
412 0x05 => SDIV => stack_io(2, 1);
413 0x06 => MOD => stack_io(2, 1);
414 0x07 => SMOD => stack_io(2, 1);
415 0x08 => ADDMOD => stack_io(3, 1);
416 0x09 => MULMOD => stack_io(3, 1);
417 0x0A => EXP => stack_io(2, 1);
418 0x0B => SIGNEXTEND => stack_io(2, 1);
419 0x10 => LT => stack_io(2, 1);
424 0x11 => GT => stack_io(2, 1);
425 0x12 => SLT => stack_io(2, 1);
426 0x13 => SGT => stack_io(2, 1);
427 0x14 => EQ => stack_io(2, 1);
428 0x15 => ISZERO => stack_io(1, 1);
429 0x16 => AND => stack_io(2, 1);
430 0x17 => OR => stack_io(2, 1);
431 0x18 => XOR => stack_io(2, 1);
432 0x19 => NOT => stack_io(1, 1);
433 0x1A => BYTE => stack_io(2, 1);
434 0x1B => SHL => stack_io(2, 1);
435 0x1C => SHR => stack_io(2, 1);
436 0x1D => SAR => stack_io(2, 1);
437 0x20 => KECCAK256 => stack_io(2, 1);
440 0x30 => ADDRESS => stack_io(0, 1);
456 0x31 => BALANCE => stack_io(1, 1);
457 0x32 => ORIGIN => stack_io(0, 1);
458 0x33 => CALLER => stack_io(0, 1);
459 0x34 => CALLVALUE => stack_io(0, 1);
460 0x35 => CALLDATALOAD => stack_io(1, 1);
461 0x36 => CALLDATASIZE => stack_io(0, 1);
462 0x37 => CALLDATACOPY => stack_io(3, 0);
463 0x38 => CODESIZE => stack_io(0, 1), not_eof;
464 0x39 => CODECOPY => stack_io(3, 0), not_eof;
465
466 0x3A => GASPRICE => stack_io(0, 1);
467 0x3B => EXTCODESIZE => stack_io(1, 1), not_eof;
468 0x3C => EXTCODECOPY => stack_io(4, 0), not_eof;
469 0x3D => RETURNDATASIZE => stack_io(0, 1);
470 0x3E => RETURNDATACOPY => stack_io(3, 0);
471 0x3F => EXTCODEHASH => stack_io(1, 1), not_eof;
472 0x40 => BLOCKHASH => stack_io(1, 1);
473 0x41 => COINBASE => stack_io(0, 1);
474 0x42 => TIMESTAMP => stack_io(0, 1);
475 0x43 => NUMBER => stack_io(0, 1);
476 0x44 => DIFFICULTY => stack_io(0, 1);
477 0x45 => GASLIMIT => stack_io(0, 1);
478 0x46 => CHAINID => stack_io(0, 1);
479 0x47 => SELFBALANCE => stack_io(0, 1);
480 0x48 => BASEFEE => stack_io(0, 1);
481 0x49 => BLOBHASH => stack_io(1, 1);
482 0x4A => BLOBBASEFEE => stack_io(0, 1);
483 0x50 => POP => stack_io(1, 0);
489 0x51 => MLOAD => stack_io(1, 1);
490 0x52 => MSTORE => stack_io(2, 0);
491 0x53 => MSTORE8 => stack_io(2, 0);
492 0x54 => SLOAD => stack_io(1, 1);
493 0x55 => SSTORE => stack_io(2, 0);
494 0x56 => JUMP => stack_io(1, 0), not_eof;
495 0x57 => JUMPI => stack_io(2, 0), not_eof;
496 0x58 => PC => stack_io(0, 1), not_eof;
497 0x59 => MSIZE => stack_io(0, 1);
498 0x5A => GAS => stack_io(0, 1), not_eof;
499 0x5B => JUMPDEST => stack_io(0, 0);
500 0x5C => TLOAD => stack_io(1, 1);
501 0x5D => TSTORE => stack_io(2, 0);
502 0x5E => MCOPY => stack_io(3, 0);
503
504 0x5F => PUSH0 => stack_io(0, 1);
505 0x60 => PUSH1 => stack_io(0, 1), immediate_size(1);
506 0x61 => PUSH2 => stack_io(0, 1), immediate_size(2);
507 0x62 => PUSH3 => stack_io(0, 1), immediate_size(3);
508 0x63 => PUSH4 => stack_io(0, 1), immediate_size(4);
509 0x64 => PUSH5 => stack_io(0, 1), immediate_size(5);
510 0x65 => PUSH6 => stack_io(0, 1), immediate_size(6);
511 0x66 => PUSH7 => stack_io(0, 1), immediate_size(7);
512 0x67 => PUSH8 => stack_io(0, 1), immediate_size(8);
513 0x68 => PUSH9 => stack_io(0, 1), immediate_size(9);
514 0x69 => PUSH10 => stack_io(0, 1), immediate_size(10);
515 0x6A => PUSH11 => stack_io(0, 1), immediate_size(11);
516 0x6B => PUSH12 => stack_io(0, 1), immediate_size(12);
517 0x6C => PUSH13 => stack_io(0, 1), immediate_size(13);
518 0x6D => PUSH14 => stack_io(0, 1), immediate_size(14);
519 0x6E => PUSH15 => stack_io(0, 1), immediate_size(15);
520 0x6F => PUSH16 => stack_io(0, 1), immediate_size(16);
521 0x70 => PUSH17 => stack_io(0, 1), immediate_size(17);
522 0x71 => PUSH18 => stack_io(0, 1), immediate_size(18);
523 0x72 => PUSH19 => stack_io(0, 1), immediate_size(19);
524 0x73 => PUSH20 => stack_io(0, 1), immediate_size(20);
525 0x74 => PUSH21 => stack_io(0, 1), immediate_size(21);
526 0x75 => PUSH22 => stack_io(0, 1), immediate_size(22);
527 0x76 => PUSH23 => stack_io(0, 1), immediate_size(23);
528 0x77 => PUSH24 => stack_io(0, 1), immediate_size(24);
529 0x78 => PUSH25 => stack_io(0, 1), immediate_size(25);
530 0x79 => PUSH26 => stack_io(0, 1), immediate_size(26);
531 0x7A => PUSH27 => stack_io(0, 1), immediate_size(27);
532 0x7B => PUSH28 => stack_io(0, 1), immediate_size(28);
533 0x7C => PUSH29 => stack_io(0, 1), immediate_size(29);
534 0x7D => PUSH30 => stack_io(0, 1), immediate_size(30);
535 0x7E => PUSH31 => stack_io(0, 1), immediate_size(31);
536 0x7F => PUSH32 => stack_io(0, 1), immediate_size(32);
537
538 0x80 => DUP1 => stack_io(1, 2);
539 0x81 => DUP2 => stack_io(2, 3);
540 0x82 => DUP3 => stack_io(3, 4);
541 0x83 => DUP4 => stack_io(4, 5);
542 0x84 => DUP5 => stack_io(5, 6);
543 0x85 => DUP6 => stack_io(6, 7);
544 0x86 => DUP7 => stack_io(7, 8);
545 0x87 => DUP8 => stack_io(8, 9);
546 0x88 => DUP9 => stack_io(9, 10);
547 0x89 => DUP10 => stack_io(10, 11);
548 0x8A => DUP11 => stack_io(11, 12);
549 0x8B => DUP12 => stack_io(12, 13);
550 0x8C => DUP13 => stack_io(13, 14);
551 0x8D => DUP14 => stack_io(14, 15);
552 0x8E => DUP15 => stack_io(15, 16);
553 0x8F => DUP16 => stack_io(16, 17);
554
555 0x90 => SWAP1 => stack_io(2, 2);
556 0x91 => SWAP2 => stack_io(3, 3);
557 0x92 => SWAP3 => stack_io(4, 4);
558 0x93 => SWAP4 => stack_io(5, 5);
559 0x94 => SWAP5 => stack_io(6, 6);
560 0x95 => SWAP6 => stack_io(7, 7);
561 0x96 => SWAP7 => stack_io(8, 8);
562 0x97 => SWAP8 => stack_io(9, 9);
563 0x98 => SWAP9 => stack_io(10, 10);
564 0x99 => SWAP10 => stack_io(11, 11);
565 0x9A => SWAP11 => stack_io(12, 12);
566 0x9B => SWAP12 => stack_io(13, 13);
567 0x9C => SWAP13 => stack_io(14, 14);
568 0x9D => SWAP14 => stack_io(15, 15);
569 0x9E => SWAP15 => stack_io(16, 16);
570 0x9F => SWAP16 => stack_io(17, 17);
571
572 0xA0 => LOG0 => stack_io(2, 0);
573 0xA1 => LOG1 => stack_io(3, 0);
574 0xA2 => LOG2 => stack_io(4, 0);
575 0xA3 => LOG3 => stack_io(5, 0);
576 0xA4 => LOG4 => stack_io(6, 0);
577 0xD0 => DATALOAD=> stack_io(1, 1);
621 0xD1 => DATALOADN => stack_io(0, 1), immediate_size(2);
622 0xD2 => DATASIZE=> stack_io(0, 1);
623 0xD3 => DATACOPY=> stack_io(3, 0);
624 0xE0 => RJUMP => stack_io(0, 0), immediate_size(2), terminating;
637 0xE1 => RJUMPI => stack_io(1, 0), immediate_size(2);
638 0xE2 => RJUMPV => stack_io(1, 0), immediate_size(1);
639 0xE3 => CALLF => stack_io(0, 0), immediate_size(2);
640 0xE4 => RETF => stack_io(0, 0), terminating;
641 0xE5 => JUMPF => stack_io(0, 0), immediate_size(2), terminating;
642 0xE6 => DUPN => stack_io(0, 1), immediate_size(1);
643 0xE7 => SWAPN => stack_io(0, 0), immediate_size(1);
644 0xE8 => EXCHANGE => stack_io(0, 0), immediate_size(1);
645 0xEC => EOFCREATE => stack_io(4, 1), immediate_size(1);
649 0xEE => RETURNCONTRACT => stack_io(2, 0), immediate_size(1), terminating;
651 0xF0 => CREATE => stack_io(3, 1), not_eof;
653 0xF1 => CALL => stack_io(7, 1), not_eof;
654 0xF2 => CALLCODE => stack_io(7, 1), not_eof;
655 0xF3 => RETURN => stack_io(2, 0), terminating;
656 0xF4 => DELEGATECALL => stack_io(6, 1), not_eof;
657 0xF5 => CREATE2 => stack_io(4, 1), not_eof;
658 0xF7 => RETURNDATALOAD => stack_io(1, 1);
660 0xF8 => EXTCALL => stack_io(4, 1);
661 0xF9 => EXTDELEGATECALL => stack_io(3, 1);
662 0xFA => STATICCALL => stack_io(6, 1), not_eof;
663 0xFB => EXTSTATICCALL => stack_io(3, 1);
664 0xFD => REVERT => stack_io(2, 0), terminating;
666 0xFE => INVALID => stack_io(0, 0), terminating;
667 0xFF => SELFDESTRUCT => stack_io(1, 0), not_eof, terminating;
668}
669
670#[cfg(test)]
671mod tests {
672 use super::*;
673
674 #[test]
675 fn test_opcode() {
676 let opcode = OpCode::new(0x00).unwrap();
677 assert!(!opcode.is_jumpdest());
678 assert!(!opcode.is_jump());
679 assert!(!opcode.is_push());
680 assert_eq!(opcode.as_str(), "STOP");
681 assert_eq!(opcode.get(), 0x00);
682 }
683
684 #[test]
685 fn test_eof_disable() {
686 const REJECTED_IN_EOF: &[u8] = &[
687 0x38, 0x39, 0x3b, 0x3c, 0x3f, 0x5a, 0xf1, 0xf2, 0xf4, 0xfa, 0xff,
688 ];
689
690 for opcode in REJECTED_IN_EOF {
691 let opcode = OpCode::new(*opcode).unwrap();
692 assert!(
693 opcode.info().is_disabled_in_eof(),
694 "not disabled in EOF: {opcode:#?}",
695 );
696 }
697 }
698
699 #[test]
700 fn test_immediate_size() {
701 let mut expected = [0u8; 256];
702 for push in PUSH1..=PUSH32 {
704 expected[push as usize] = push - PUSH1 + 1;
705 }
706 expected[DATALOADN as usize] = 2;
707 expected[RJUMP as usize] = 2;
708 expected[RJUMPI as usize] = 2;
709 expected[RJUMPV as usize] = 1;
710 expected[CALLF as usize] = 2;
711 expected[JUMPF as usize] = 2;
712 expected[DUPN as usize] = 1;
713 expected[SWAPN as usize] = 1;
714 expected[EXCHANGE as usize] = 1;
715 expected[EOFCREATE as usize] = 1;
716 expected[RETURNCONTRACT as usize] = 1;
717
718 for (i, opcode) in OPCODE_INFO.iter().enumerate() {
719 if let Some(opcode) = opcode {
720 assert_eq!(
721 opcode.immediate_size(),
722 expected[i],
723 "immediate_size check failed for {opcode:#?}",
724 );
725 }
726 }
727 }
728
729 #[test]
730 fn test_enabled_opcodes() {
731 let opcodes = [
733 0x10..=0x1d,
734 0x20..=0x20,
735 0x30..=0x3f,
736 0x40..=0x48,
737 0x50..=0x5b,
738 0x54..=0x5f,
739 0x60..=0x6f,
740 0x70..=0x7f,
741 0x80..=0x8f,
742 0x90..=0x9f,
743 0xa0..=0xa4,
744 0xf0..=0xf5,
745 0xfa..=0xfa,
746 0xfd..=0xfd,
747 0xff..=0xff,
749 ];
750 for i in opcodes {
751 for opcode in i {
752 OpCode::new(opcode).expect("Opcode should be valid and enabled");
753 }
754 }
755 }
756
757 #[test]
758 fn count_opcodes() {
759 let mut opcode_num = 0;
760 let mut eof_opcode_num = 0;
761 for opcode in OPCODE_INFO.into_iter().flatten() {
762 opcode_num += 1;
763 if !opcode.is_disabled_in_eof() {
764 eof_opcode_num += 1;
765 }
766 }
767 assert_eq!(opcode_num, 168);
768 assert_eq!(eof_opcode_num, 152);
769 }
770
771 #[test]
772 fn test_terminating_opcodes() {
773 let terminating = [
774 RETF,
775 REVERT,
776 RETURN,
777 INVALID,
778 SELFDESTRUCT,
779 RETURNCONTRACT,
780 STOP,
781 RJUMP,
782 JUMPF,
783 ];
784 let mut opcodes = [false; 256];
785 for terminating in terminating.iter() {
786 opcodes[*terminating as usize] = true;
787 }
788
789 for (i, opcode) in OPCODE_INFO.into_iter().enumerate() {
790 assert_eq!(
791 opcode.map(|opcode| opcode.terminating).unwrap_or_default(),
792 opcodes[i],
793 "Opcode {:?} terminating check failed.",
794 opcode
795 );
796 }
797 }
798
799 #[test]
800 #[cfg(feature = "parse")]
801 fn test_parsing() {
802 for i in 0..=u8::MAX {
803 if let Some(op) = OpCode::new(i) {
804 assert_eq!(OpCode::parse(op.as_str()), Some(op));
805 }
806 }
807 }
808}