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 )
197 }
198}
199
200impl PartialEq<u8> for OpCode {
201 fn eq(&self, other: &u8) -> bool {
202 self.get().eq(other)
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 terminating: bool,
226}
227
228unsafe impl Send for OpCodeInfo {}
230unsafe impl Sync for OpCodeInfo {}
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("terminating", &self.is_terminating())
239 .field("immediate_size", &self.immediate_size())
240 .finish()
241 }
242}
243
244impl OpCodeInfo {
245 pub const fn new(name: &'static str) -> Self {
247 assert!(name.len() < 256, "opcode name is too long");
248 Self {
249 name_ptr: unsafe { NonNull::new_unchecked(name.as_ptr().cast_mut()) },
250 name_len: name.len() as u8,
251 inputs: 0,
252 outputs: 0,
253 terminating: false,
254 immediate_size: 0,
255 }
256 }
257
258 #[inline]
260 pub const fn name(&self) -> &'static str {
261 unsafe {
263 let slice = std::slice::from_raw_parts(self.name_ptr.as_ptr(), self.name_len as usize);
264 core::str::from_utf8_unchecked(slice)
265 }
266 }
267
268 #[inline]
270 pub const fn io_diff(&self) -> i16 {
271 self.outputs as i16 - self.inputs as i16
272 }
273
274 #[inline]
276 pub const fn inputs(&self) -> u8 {
277 self.inputs
278 }
279
280 #[inline]
282 pub const fn outputs(&self) -> u8 {
283 self.outputs
284 }
285
286 #[inline]
288 pub const fn is_terminating(&self) -> bool {
289 self.terminating
290 }
291
292 #[inline]
294 pub const fn immediate_size(&self) -> u8 {
295 self.immediate_size
296 }
297}
298
299#[inline]
304pub const fn immediate_size(mut op: OpCodeInfo, n: u8) -> OpCodeInfo {
305 op.immediate_size = n;
306 op
307}
308
309#[inline]
311pub const fn terminating(mut op: OpCodeInfo) -> OpCodeInfo {
312 op.terminating = true;
313 op
314}
315
316#[inline]
318pub const fn stack_io(mut op: OpCodeInfo, inputs: u8, outputs: u8) -> OpCodeInfo {
319 op.inputs = inputs;
320 op.outputs = outputs;
321 op
322}
323
324pub const NOP: u8 = JUMPDEST;
326
327macro_rules! opcodes {
331 ($($val:literal => $name:ident => $($modifier:ident $(( $($modifier_arg:expr),* ))?),*);* $(;)?) => {
332 $(
334 #[doc = concat!("The `", stringify!($val), "` (\"", stringify!($name),"\") opcode.")]
335 pub const $name: u8 = $val;
336 )*
337 impl OpCode {$(
338 #[doc = concat!("The `", stringify!($val), "` (\"", stringify!($name),"\") opcode.")]
339 pub const $name: Self = Self($val);
340 )*}
341
342 pub static OPCODE_INFO: [Option<OpCodeInfo>; 256] = {
344 let mut map = [None; 256];
345 let mut prev: u8 = 0;
346 $(
347 let val: u8 = $val;
348 assert!(val == 0 || val > prev, "opcodes must be sorted in ascending order");
349 prev = val;
350 let info = OpCodeInfo::new(stringify!($name));
351 $(
352 let info = $modifier(info, $($($modifier_arg),*)?);
353 )*
354 map[$val] = Some(info);
355 )*
356 let _ = prev;
357 map
358 };
359
360
361 #[cfg(feature = "parse")]
363 pub(crate) static NAME_TO_OPCODE: phf::Map<&'static str, OpCode> = stringify_with_cb! { phf_map_cb; $($name)* };
364 };
365}
366
367#[cfg(feature = "parse")]
369macro_rules! phf_map_cb {
370 ($(#[doc = $s:literal] $id:ident)*) => {
371 phf::phf_map! {
372 $($s => OpCode::$id),*
373 }
374 };
375}
376
377#[cfg(feature = "parse")]
381macro_rules! stringify_with_cb {
382 ($callback:ident; $($id:ident)*) => { paste::paste! {
383 $callback! { $(#[doc = "" $id ""] $id)* }
384 }};
385}
386
387opcodes! {
392 0x00 => STOP => stack_io(0, 0), terminating;
393 0x01 => ADD => stack_io(2, 1);
394 0x02 => MUL => stack_io(2, 1);
395 0x03 => SUB => stack_io(2, 1);
396 0x04 => DIV => stack_io(2, 1);
397 0x05 => SDIV => stack_io(2, 1);
398 0x06 => MOD => stack_io(2, 1);
399 0x07 => SMOD => stack_io(2, 1);
400 0x08 => ADDMOD => stack_io(3, 1);
401 0x09 => MULMOD => stack_io(3, 1);
402 0x0A => EXP => stack_io(2, 1);
403 0x0B => SIGNEXTEND => stack_io(2, 1);
404 0x10 => LT => stack_io(2, 1);
409 0x11 => GT => stack_io(2, 1);
410 0x12 => SLT => stack_io(2, 1);
411 0x13 => SGT => stack_io(2, 1);
412 0x14 => EQ => stack_io(2, 1);
413 0x15 => ISZERO => stack_io(1, 1);
414 0x16 => AND => stack_io(2, 1);
415 0x17 => OR => stack_io(2, 1);
416 0x18 => XOR => stack_io(2, 1);
417 0x19 => NOT => stack_io(1, 1);
418 0x1A => BYTE => stack_io(2, 1);
419 0x1B => SHL => stack_io(2, 1);
420 0x1C => SHR => stack_io(2, 1);
421 0x1D => SAR => stack_io(2, 1);
422 0x1E => CLZ => stack_io(1, 1);
423 0x20 => KECCAK256 => stack_io(2, 1);
425 0x30 => ADDRESS => stack_io(0, 1);
441 0x31 => BALANCE => stack_io(1, 1);
442 0x32 => ORIGIN => stack_io(0, 1);
443 0x33 => CALLER => stack_io(0, 1);
444 0x34 => CALLVALUE => stack_io(0, 1);
445 0x35 => CALLDATALOAD => stack_io(1, 1);
446 0x36 => CALLDATASIZE => stack_io(0, 1);
447 0x37 => CALLDATACOPY => stack_io(3, 0);
448 0x38 => CODESIZE => stack_io(0, 1);
449 0x39 => CODECOPY => stack_io(3, 0);
450
451 0x3A => GASPRICE => stack_io(0, 1);
452 0x3B => EXTCODESIZE => stack_io(1, 1);
453 0x3C => EXTCODECOPY => stack_io(4, 0);
454 0x3D => RETURNDATASIZE => stack_io(0, 1);
455 0x3E => RETURNDATACOPY => stack_io(3, 0);
456 0x3F => EXTCODEHASH => stack_io(1, 1);
457 0x40 => BLOCKHASH => stack_io(1, 1);
458 0x41 => COINBASE => stack_io(0, 1);
459 0x42 => TIMESTAMP => stack_io(0, 1);
460 0x43 => NUMBER => stack_io(0, 1);
461 0x44 => DIFFICULTY => stack_io(0, 1);
462 0x45 => GASLIMIT => stack_io(0, 1);
463 0x46 => CHAINID => stack_io(0, 1);
464 0x47 => SELFBALANCE => stack_io(0, 1);
465 0x48 => BASEFEE => stack_io(0, 1);
466 0x49 => BLOBHASH => stack_io(1, 1);
467 0x4A => BLOBBASEFEE => stack_io(0, 1);
468 0x50 => POP => stack_io(1, 0);
474 0x51 => MLOAD => stack_io(1, 1);
475 0x52 => MSTORE => stack_io(2, 0);
476 0x53 => MSTORE8 => stack_io(2, 0);
477 0x54 => SLOAD => stack_io(1, 1);
478 0x55 => SSTORE => stack_io(2, 0);
479 0x56 => JUMP => stack_io(1, 0);
480 0x57 => JUMPI => stack_io(2, 0);
481 0x58 => PC => stack_io(0, 1);
482 0x59 => MSIZE => stack_io(0, 1);
483 0x5A => GAS => stack_io(0, 1);
484 0x5B => JUMPDEST => stack_io(0, 0);
485 0x5C => TLOAD => stack_io(1, 1);
486 0x5D => TSTORE => stack_io(2, 0);
487 0x5E => MCOPY => stack_io(3, 0);
488
489 0x5F => PUSH0 => stack_io(0, 1);
490 0x60 => PUSH1 => stack_io(0, 1), immediate_size(1);
491 0x61 => PUSH2 => stack_io(0, 1), immediate_size(2);
492 0x62 => PUSH3 => stack_io(0, 1), immediate_size(3);
493 0x63 => PUSH4 => stack_io(0, 1), immediate_size(4);
494 0x64 => PUSH5 => stack_io(0, 1), immediate_size(5);
495 0x65 => PUSH6 => stack_io(0, 1), immediate_size(6);
496 0x66 => PUSH7 => stack_io(0, 1), immediate_size(7);
497 0x67 => PUSH8 => stack_io(0, 1), immediate_size(8);
498 0x68 => PUSH9 => stack_io(0, 1), immediate_size(9);
499 0x69 => PUSH10 => stack_io(0, 1), immediate_size(10);
500 0x6A => PUSH11 => stack_io(0, 1), immediate_size(11);
501 0x6B => PUSH12 => stack_io(0, 1), immediate_size(12);
502 0x6C => PUSH13 => stack_io(0, 1), immediate_size(13);
503 0x6D => PUSH14 => stack_io(0, 1), immediate_size(14);
504 0x6E => PUSH15 => stack_io(0, 1), immediate_size(15);
505 0x6F => PUSH16 => stack_io(0, 1), immediate_size(16);
506 0x70 => PUSH17 => stack_io(0, 1), immediate_size(17);
507 0x71 => PUSH18 => stack_io(0, 1), immediate_size(18);
508 0x72 => PUSH19 => stack_io(0, 1), immediate_size(19);
509 0x73 => PUSH20 => stack_io(0, 1), immediate_size(20);
510 0x74 => PUSH21 => stack_io(0, 1), immediate_size(21);
511 0x75 => PUSH22 => stack_io(0, 1), immediate_size(22);
512 0x76 => PUSH23 => stack_io(0, 1), immediate_size(23);
513 0x77 => PUSH24 => stack_io(0, 1), immediate_size(24);
514 0x78 => PUSH25 => stack_io(0, 1), immediate_size(25);
515 0x79 => PUSH26 => stack_io(0, 1), immediate_size(26);
516 0x7A => PUSH27 => stack_io(0, 1), immediate_size(27);
517 0x7B => PUSH28 => stack_io(0, 1), immediate_size(28);
518 0x7C => PUSH29 => stack_io(0, 1), immediate_size(29);
519 0x7D => PUSH30 => stack_io(0, 1), immediate_size(30);
520 0x7E => PUSH31 => stack_io(0, 1), immediate_size(31);
521 0x7F => PUSH32 => stack_io(0, 1), immediate_size(32);
522
523 0x80 => DUP1 => stack_io(1, 2);
524 0x81 => DUP2 => stack_io(2, 3);
525 0x82 => DUP3 => stack_io(3, 4);
526 0x83 => DUP4 => stack_io(4, 5);
527 0x84 => DUP5 => stack_io(5, 6);
528 0x85 => DUP6 => stack_io(6, 7);
529 0x86 => DUP7 => stack_io(7, 8);
530 0x87 => DUP8 => stack_io(8, 9);
531 0x88 => DUP9 => stack_io(9, 10);
532 0x89 => DUP10 => stack_io(10, 11);
533 0x8A => DUP11 => stack_io(11, 12);
534 0x8B => DUP12 => stack_io(12, 13);
535 0x8C => DUP13 => stack_io(13, 14);
536 0x8D => DUP14 => stack_io(14, 15);
537 0x8E => DUP15 => stack_io(15, 16);
538 0x8F => DUP16 => stack_io(16, 17);
539
540 0x90 => SWAP1 => stack_io(2, 2);
541 0x91 => SWAP2 => stack_io(3, 3);
542 0x92 => SWAP3 => stack_io(4, 4);
543 0x93 => SWAP4 => stack_io(5, 5);
544 0x94 => SWAP5 => stack_io(6, 6);
545 0x95 => SWAP6 => stack_io(7, 7);
546 0x96 => SWAP7 => stack_io(8, 8);
547 0x97 => SWAP8 => stack_io(9, 9);
548 0x98 => SWAP9 => stack_io(10, 10);
549 0x99 => SWAP10 => stack_io(11, 11);
550 0x9A => SWAP11 => stack_io(12, 12);
551 0x9B => SWAP12 => stack_io(13, 13);
552 0x9C => SWAP13 => stack_io(14, 14);
553 0x9D => SWAP14 => stack_io(15, 15);
554 0x9E => SWAP15 => stack_io(16, 16);
555 0x9F => SWAP16 => stack_io(17, 17);
556
557 0xA0 => LOG0 => stack_io(2, 0);
558 0xA1 => LOG1 => stack_io(3, 0);
559 0xA2 => LOG2 => stack_io(4, 0);
560 0xA3 => LOG3 => stack_io(5, 0);
561 0xA4 => LOG4 => stack_io(6, 0);
562 0xF0 => CREATE => stack_io(3, 1);
638 0xF1 => CALL => stack_io(7, 1);
639 0xF2 => CALLCODE => stack_io(7, 1);
640 0xF3 => RETURN => stack_io(2, 0), terminating;
641 0xF4 => DELEGATECALL => stack_io(6, 1);
642 0xF5 => CREATE2 => stack_io(4, 1);
643 0xFA => STATICCALL => stack_io(6, 1);
648 0xFD => REVERT => stack_io(2, 0), terminating;
651 0xFE => INVALID => stack_io(0, 0), terminating;
652 0xFF => SELFDESTRUCT => stack_io(1, 0), terminating;
653}
654
655#[cfg(test)]
656mod tests {
657 use super::*;
658
659 #[test]
660 fn test_opcode() {
661 let opcode = OpCode::new(0x00).unwrap();
662 assert!(!opcode.is_jumpdest());
663 assert!(!opcode.is_jump());
664 assert!(!opcode.is_push());
665 assert_eq!(opcode.as_str(), "STOP");
666 assert_eq!(opcode.get(), 0x00);
667 }
668
669 #[test]
670 fn test_immediate_size() {
671 let mut expected = [0u8; 256];
672 for push in PUSH1..=PUSH32 {
674 expected[push as usize] = push - PUSH1 + 1;
675 }
676
677 for (i, opcode) in OPCODE_INFO.iter().enumerate() {
678 if let Some(opcode) = opcode {
679 assert_eq!(
680 opcode.immediate_size(),
681 expected[i],
682 "immediate_size check failed for {opcode:#?}",
683 );
684 }
685 }
686 }
687
688 #[test]
689 fn test_enabled_opcodes() {
690 let opcodes = [
692 0x10..=0x1d,
693 0x20..=0x20,
694 0x30..=0x3f,
695 0x40..=0x48,
696 0x50..=0x5b,
697 0x54..=0x5f,
698 0x60..=0x6f,
699 0x70..=0x7f,
700 0x80..=0x8f,
701 0x90..=0x9f,
702 0xa0..=0xa4,
703 0xf0..=0xf5,
704 0xfa..=0xfa,
705 0xfd..=0xfd,
706 0xff..=0xff,
708 ];
709 for i in opcodes {
710 for opcode in i {
711 OpCode::new(opcode).expect("Opcode should be valid and enabled");
712 }
713 }
714 }
715
716 #[test]
717 fn count_opcodes() {
718 let mut opcode_num = 0;
719 for _ in OPCODE_INFO.into_iter().flatten() {
720 opcode_num += 1;
721 }
722 assert_eq!(opcode_num, 150);
723 }
724
725 #[test]
726 fn test_terminating_opcodes() {
727 let terminating = [REVERT, RETURN, INVALID, SELFDESTRUCT, STOP];
728 let mut opcodes = [false; 256];
729 for terminating in terminating.iter() {
730 opcodes[*terminating as usize] = true;
731 }
732
733 for (i, opcode) in OPCODE_INFO.into_iter().enumerate() {
734 assert_eq!(
735 opcode.map(|opcode| opcode.terminating).unwrap_or_default(),
736 opcodes[i],
737 "Opcode {opcode:?} terminating check failed."
738 );
739 }
740 }
741
742 #[test]
743 #[cfg(feature = "parse")]
744 fn test_parsing() {
745 for i in 0..=u8::MAX {
746 if let Some(op) = OpCode::new(i) {
747 assert_eq!(OpCode::parse(op.as_str()), Some(op));
748 }
749 }
750 }
751}