1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
pub mod eof;
pub mod legacy;
pub use eof::Eof;
pub use legacy::{JumpTable, LegacyAnalyzedBytecode};
use crate::{keccak256, Bytes, B256, KECCAK_EMPTY};
/// State of the [`Bytecode`] analysis.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Bytecode {
/// No analysis has been performed.
LegacyRaw(Bytes),
/// The bytecode has been analyzed for valid jump destinations.
LegacyAnalyzed(LegacyAnalyzedBytecode),
/// Ethereum Object Format
Eof(Eof),
}
impl Default for Bytecode {
#[inline]
fn default() -> Self {
// Creates a new legacy analyzed [`Bytecode`] with exactly one STOP opcode.
Self::new()
}
}
impl Bytecode {
// Creates a new legacy analyzed [`Bytecode`] with exactly one STOP opcode.
#[inline]
pub fn new() -> Self {
Self::LegacyAnalyzed(LegacyAnalyzedBytecode::default())
}
/// Return jump table if bytecode is analyzed
#[inline]
pub fn legacy_jump_table(&self) -> Option<&JumpTable> {
match &self {
Self::LegacyAnalyzed(analyzed) => Some(analyzed.jump_table()),
_ => None,
}
}
/// Calculate hash of the bytecode.
pub fn hash_slow(&self) -> B256 {
if self.is_empty() {
KECCAK_EMPTY
} else {
keccak256(self.original_byte_slice())
}
}
/// Return reference to the EOF if bytecode is EOF.
#[inline]
pub const fn eof(&self) -> Option<&Eof> {
match self {
Self::Eof(eof) => Some(eof),
_ => None,
}
}
/// Return true if bytecode is EOF.
#[inline]
pub const fn is_eof(&self) -> bool {
matches!(self, Self::Eof(_))
}
/// Creates a new raw [`Bytecode`].
#[inline]
pub fn new_raw(bytecode: Bytes) -> Self {
Self::LegacyRaw(bytecode)
}
/// Create new checked bytecode.
///
/// # Safety
///
/// Bytecode needs to end with STOP (0x00) opcode as checked bytecode assumes
/// that it is safe to iterate over bytecode without checking lengths.
pub unsafe fn new_analyzed(
bytecode: Bytes,
original_len: usize,
jump_table: JumpTable,
) -> Self {
Self::LegacyAnalyzed(LegacyAnalyzedBytecode::new(
bytecode,
original_len,
jump_table,
))
}
/// Returns a reference to the bytecode.
/// In case of EOF this will be the first code section.
#[inline]
pub fn bytecode_bytes(&self) -> Bytes {
match self {
Self::LegacyRaw(bytes) => bytes.clone(),
Self::LegacyAnalyzed(analyzed) => analyzed.bytes(),
Self::Eof(eof) => eof
.body
.code(0)
.expect("Valid EOF has at least one code section")
.clone(),
}
}
/// Returns false if bytecode can't be executed in Interpreter.
pub fn is_execution_ready(&self) -> bool {
!matches!(self, Self::LegacyRaw(_))
}
/// Returns a reference to the original bytecode.
#[inline]
pub fn original_bytes(&self) -> Bytes {
match self {
Self::LegacyRaw(bytes) => bytes.clone(),
Self::LegacyAnalyzed(analyzed) => analyzed.original_bytes(),
Self::Eof(eof) => eof.raw().clone(),
}
}
/// Returns the original bytecode as a byte slice.
#[inline]
pub fn original_byte_slice(&self) -> &[u8] {
match self {
Self::LegacyRaw(bytes) => bytes,
Self::LegacyAnalyzed(analyzed) => analyzed.original_byte_slice(),
Self::Eof(eof) => eof.raw(),
}
}
/// Returns the length of the raw bytes.
#[inline]
pub fn len(&self) -> usize {
match self {
Self::LegacyRaw(bytes) => bytes.len(),
Self::LegacyAnalyzed(analyzed) => analyzed.original_len(),
Self::Eof(eof) => eof.size(),
}
}
/// Returns whether the bytecode is empty.
#[inline]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
}