Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
bitwise_trace.test.cpp
Go to the documentation of this file.
1#include <gmock/gmock.h>
2#include <gtest/gtest.h>
3
4#include <cstdint>
5
6#include "barretenberg/vm2/common/memory_types.hpp"
7#include "barretenberg/vm2/testing/macros.hpp"
8#include "barretenberg/vm2/tracegen/bitwise_trace.hpp"
9#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
10
11namespace bb::avm2::tracegen {
12namespace {
13
14using testing::ElementsAre;
15
16TEST(BitwiseTraceGenTest, U1And)
17{
18 TestTraceContainer trace;
19 BitwiseTraceBuilder builder;
20
21 builder.process(
22 {
23 {
24 .operation = BitwiseOperation::AND,
25 .a = MemoryValue::from(uint1_t(0)),
26 .b = MemoryValue::from(uint1_t(1)),
27 .res = 0,
28 },
29 },
30 trace);
31
32 EXPECT_EQ(trace.as_rows().size(), 2);
33
34 EXPECT_THAT(trace.as_rows(),
35 ElementsAre(AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
36 ROW_FIELD_EQ(bitwise_acc_ia, 0),
37 ROW_FIELD_EQ(bitwise_acc_ib, 0),
38 ROW_FIELD_EQ(bitwise_acc_ic, 0),
39 ROW_FIELD_EQ(bitwise_ia_byte, 0),
40 ROW_FIELD_EQ(bitwise_ib_byte, 0),
41 ROW_FIELD_EQ(bitwise_ic_byte, 0),
42 ROW_FIELD_EQ(bitwise_ctr, 0),
43 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
44 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
45 ROW_FIELD_EQ(bitwise_last, 1),
46 ROW_FIELD_EQ(bitwise_sel, 0),
47 ROW_FIELD_EQ(bitwise_start, 0)),
48 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
49 ROW_FIELD_EQ(bitwise_acc_ia, 0),
50 ROW_FIELD_EQ(bitwise_acc_ib, 1),
51 ROW_FIELD_EQ(bitwise_acc_ic, 0),
52 ROW_FIELD_EQ(bitwise_ia_byte, 0),
53 ROW_FIELD_EQ(bitwise_ib_byte, 1),
54 ROW_FIELD_EQ(bitwise_ic_byte, 0),
55 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(MemoryTag::U1)),
56 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(MemoryTag::U1)),
57 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(MemoryTag::U1)),
58 ROW_FIELD_EQ(bitwise_ctr, 1),
59 ROW_FIELD_EQ(bitwise_ctr_inv, 1),
60 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 1),
61 ROW_FIELD_EQ(bitwise_last, 1),
62 ROW_FIELD_EQ(bitwise_sel, 1),
63 ROW_FIELD_EQ(bitwise_sel_get_ctr, 1),
64 ROW_FIELD_EQ(bitwise_start, 1))));
65}
66
67TEST(BitwiseTraceGenTest, U32And)
68{
69 TestTraceContainer trace;
70 BitwiseTraceBuilder builder;
71
72 builder.process(
73 {
74 {
75 .operation = BitwiseOperation::AND,
76 .a = MemoryValue::from<uint32_t>(0x52488425),
77 .b = MemoryValue::from<uint32_t>(0xC684486C),
78 .res = 0x42000024,
79 },
80 },
81 trace);
82
83 EXPECT_EQ(trace.as_rows().size(), 5);
84
85 EXPECT_THAT(trace.as_rows(),
86 ElementsAre(AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
87 ROW_FIELD_EQ(bitwise_acc_ia, 0),
88 ROW_FIELD_EQ(bitwise_acc_ib, 0),
89 ROW_FIELD_EQ(bitwise_acc_ic, 0),
90 ROW_FIELD_EQ(bitwise_ia_byte, 0),
91 ROW_FIELD_EQ(bitwise_ib_byte, 0),
92 ROW_FIELD_EQ(bitwise_ic_byte, 0),
93 ROW_FIELD_EQ(bitwise_ctr, 0),
94 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
95 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
96 ROW_FIELD_EQ(bitwise_last, 1),
97 ROW_FIELD_EQ(bitwise_sel, 0),
98 ROW_FIELD_EQ(bitwise_start, 0)),
99 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
100 ROW_FIELD_EQ(bitwise_acc_ia, 0x52488425),
101 ROW_FIELD_EQ(bitwise_acc_ib, 0xC684486C),
102 ROW_FIELD_EQ(bitwise_acc_ic, 0x42000024),
103 ROW_FIELD_EQ(bitwise_ia_byte, 0x25),
104 ROW_FIELD_EQ(bitwise_ib_byte, 0x6C),
105 ROW_FIELD_EQ(bitwise_ic_byte, 0x24),
106 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(MemoryTag::U32)),
107 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(MemoryTag::U32)),
108 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(MemoryTag::U32)),
109 ROW_FIELD_EQ(bitwise_ctr, 4),
110 ROW_FIELD_EQ(bitwise_ctr_inv, FF(4).invert()),
111 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, FF(3).invert()),
112 ROW_FIELD_EQ(bitwise_last, 0),
113 ROW_FIELD_EQ(bitwise_sel, 1),
114 ROW_FIELD_EQ(bitwise_sel_get_ctr, 1),
115 ROW_FIELD_EQ(bitwise_start, 1)),
116 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
117 ROW_FIELD_EQ(bitwise_acc_ia, 0x524884),
118 ROW_FIELD_EQ(bitwise_acc_ib, 0xC68448),
119 ROW_FIELD_EQ(bitwise_acc_ic, 0x420000),
120 ROW_FIELD_EQ(bitwise_ia_byte, 0x84),
121 ROW_FIELD_EQ(bitwise_ib_byte, 0x48),
122 ROW_FIELD_EQ(bitwise_ic_byte, 0x00),
123 ROW_FIELD_EQ(bitwise_tag_a, 0),
124 ROW_FIELD_EQ(bitwise_tag_b, 0),
125 ROW_FIELD_EQ(bitwise_tag_c, 0),
126 ROW_FIELD_EQ(bitwise_ctr, 3),
127 ROW_FIELD_EQ(bitwise_ctr_inv, FF(3).invert()),
128 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, FF(2).invert()),
129 ROW_FIELD_EQ(bitwise_last, 0),
130 ROW_FIELD_EQ(bitwise_sel, 1),
131 ROW_FIELD_EQ(bitwise_start, 0)),
132 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
133 ROW_FIELD_EQ(bitwise_acc_ia, 0x5248),
134 ROW_FIELD_EQ(bitwise_acc_ib, 0xC684),
135 ROW_FIELD_EQ(bitwise_acc_ic, 0x4200),
136 ROW_FIELD_EQ(bitwise_ia_byte, 0x48),
137 ROW_FIELD_EQ(bitwise_ib_byte, 0x84),
138 ROW_FIELD_EQ(bitwise_ic_byte, 0x00),
139 ROW_FIELD_EQ(bitwise_tag_a, 0),
140 ROW_FIELD_EQ(bitwise_tag_b, 0),
141 ROW_FIELD_EQ(bitwise_tag_c, 0),
142 ROW_FIELD_EQ(bitwise_ctr, 2),
143 ROW_FIELD_EQ(bitwise_ctr_inv, FF(2).invert()),
144 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 1),
145 ROW_FIELD_EQ(bitwise_last, 0),
146 ROW_FIELD_EQ(bitwise_sel, 1),
147 ROW_FIELD_EQ(bitwise_start, 0)),
148 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
149 ROW_FIELD_EQ(bitwise_acc_ia, 0x52),
150 ROW_FIELD_EQ(bitwise_acc_ib, 0xC6),
151 ROW_FIELD_EQ(bitwise_acc_ic, 0x42),
152 ROW_FIELD_EQ(bitwise_ia_byte, 0x52),
153 ROW_FIELD_EQ(bitwise_ib_byte, 0xC6),
154 ROW_FIELD_EQ(bitwise_ic_byte, 0x42),
155 ROW_FIELD_EQ(bitwise_tag_a, 0),
156 ROW_FIELD_EQ(bitwise_tag_b, 0),
157 ROW_FIELD_EQ(bitwise_tag_c, 0),
158 ROW_FIELD_EQ(bitwise_ctr, 1),
159 ROW_FIELD_EQ(bitwise_ctr_inv, 1),
160 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 1),
161 ROW_FIELD_EQ(bitwise_last, 1),
162 ROW_FIELD_EQ(bitwise_sel, 1),
163 ROW_FIELD_EQ(bitwise_start, 0))));
164}
165
166TEST(BitwiseTraceGenTest, ErrorInputFF)
167{
168 TestTraceContainer trace;
169 BitwiseTraceBuilder builder;
170
171 std::vector<simulation::BitwiseEvent> events = {
172 { .operation = BitwiseOperation::AND,
173 .a = MemoryValue::from_tag(ValueTag::FF, 1),
174 .b = MemoryValue::from_tag(ValueTag::FF, 1),
175 .res = 0 },
176 };
177 builder.process(events, trace);
178
179 EXPECT_THAT(trace.as_rows(),
180 ElementsAre(AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
181 ROW_FIELD_EQ(bitwise_acc_ia, 0),
182 ROW_FIELD_EQ(bitwise_acc_ib, 0),
183 ROW_FIELD_EQ(bitwise_acc_ic, 0),
184 ROW_FIELD_EQ(bitwise_ia_byte, 0),
185 ROW_FIELD_EQ(bitwise_ib_byte, 0),
186 ROW_FIELD_EQ(bitwise_ic_byte, 0),
187 ROW_FIELD_EQ(bitwise_ctr, 0),
188 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
189 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
190 ROW_FIELD_EQ(bitwise_last, 1),
191 ROW_FIELD_EQ(bitwise_sel, 0)),
192 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
193 ROW_FIELD_EQ(bitwise_acc_ia, 1),
194 ROW_FIELD_EQ(bitwise_acc_ib, 1),
195 ROW_FIELD_EQ(bitwise_acc_ic, 0),
196 ROW_FIELD_EQ(bitwise_ia_byte, 1),
197 ROW_FIELD_EQ(bitwise_ib_byte, 1),
198 ROW_FIELD_EQ(bitwise_ic_byte, 0),
199 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(ValueTag::FF)),
200 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(ValueTag::FF)),
201 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(ValueTag::FF)),
202 ROW_FIELD_EQ(bitwise_ctr, 0),
203 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
204 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
205 ROW_FIELD_EQ(bitwise_last, 1),
206 // Err Flags
207 ROW_FIELD_EQ(bitwise_sel_tag_ff_err, 1),
208 ROW_FIELD_EQ(bitwise_sel_tag_mismatch_err, 0),
209 ROW_FIELD_EQ(bitwise_err, 1),
210 ROW_FIELD_EQ(bitwise_tag_a_inv, 0))));
211}
212
213TEST(BitwiseTraceGenTest, ErrorTagMismatch)
214{
215 TestTraceContainer trace;
216 BitwiseTraceBuilder builder;
217
218 std::vector<simulation::BitwiseEvent> events = {
219 { .operation = BitwiseOperation::AND,
220 .a = MemoryValue::from_tag(ValueTag::U8, 1),
221 .b = MemoryValue::from_tag(ValueTag::U16, 1),
222 .res = 0 },
223 };
224 builder.process(events, trace);
225
226 EXPECT_THAT(
227 trace.as_rows(),
228 ElementsAre(AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
229 ROW_FIELD_EQ(bitwise_acc_ia, 0),
230 ROW_FIELD_EQ(bitwise_acc_ib, 0),
231 ROW_FIELD_EQ(bitwise_acc_ic, 0),
232 ROW_FIELD_EQ(bitwise_ia_byte, 0),
233 ROW_FIELD_EQ(bitwise_ib_byte, 0),
234 ROW_FIELD_EQ(bitwise_ic_byte, 0),
235 ROW_FIELD_EQ(bitwise_ctr, 0),
236 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
237 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
238 ROW_FIELD_EQ(bitwise_last, 1),
239 ROW_FIELD_EQ(bitwise_sel, 0)),
240 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
241 ROW_FIELD_EQ(bitwise_acc_ia, 1),
242 ROW_FIELD_EQ(bitwise_acc_ib, 1),
243 ROW_FIELD_EQ(bitwise_acc_ic, 0),
244 ROW_FIELD_EQ(bitwise_ia_byte, 1),
245 ROW_FIELD_EQ(bitwise_ib_byte, 1),
246 ROW_FIELD_EQ(bitwise_ic_byte, 0),
247 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(ValueTag::U8)),
248 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(ValueTag::U16)),
249 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(ValueTag::U8)),
250 ROW_FIELD_EQ(bitwise_ctr, 0),
251 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
252 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
253 ROW_FIELD_EQ(bitwise_last, 1),
254 // Err Flags
255 ROW_FIELD_EQ(bitwise_sel_tag_ff_err, 0),
256 ROW_FIELD_EQ(bitwise_sel_tag_mismatch_err, 1),
257 ROW_FIELD_EQ(bitwise_err, 1),
258 ROW_FIELD_EQ(
259 bitwise_tag_ab_diff_inv,
260 FF(static_cast<uint8_t>(ValueTag::U8) - static_cast<uint8_t>(ValueTag::U16)).invert()))));
261}
262
263TEST(BitwiseTraceGenTest, ErrorFFAndTagMismatch)
264{
265 TestTraceContainer trace;
266 BitwiseTraceBuilder builder;
267
268 std::vector<simulation::BitwiseEvent> events = {
269 { .operation = BitwiseOperation::AND,
270 .a = MemoryValue::from_tag(ValueTag::FF, 1),
271 .b = MemoryValue::from_tag(ValueTag::U16, 1),
272 .res = 0 },
273 };
274 builder.process(events, trace);
275
276 EXPECT_THAT(
277 trace.as_rows(),
278 ElementsAre(
279 AllOf(ROW_FIELD_EQ(bitwise_op_id, 0),
280 ROW_FIELD_EQ(bitwise_acc_ia, 0),
281 ROW_FIELD_EQ(bitwise_acc_ib, 0),
282 ROW_FIELD_EQ(bitwise_acc_ic, 0),
283 ROW_FIELD_EQ(bitwise_ia_byte, 0),
284 ROW_FIELD_EQ(bitwise_ib_byte, 0),
285 ROW_FIELD_EQ(bitwise_ic_byte, 0),
286 ROW_FIELD_EQ(bitwise_ctr, 0),
287 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
288 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
289 ROW_FIELD_EQ(bitwise_last, 1),
290 ROW_FIELD_EQ(bitwise_sel, 0)),
291 AllOf(ROW_FIELD_EQ(bitwise_op_id, static_cast<uint8_t>(BitwiseOperation::AND)),
292 ROW_FIELD_EQ(bitwise_acc_ia, 1),
293 ROW_FIELD_EQ(bitwise_acc_ib, 1),
294 ROW_FIELD_EQ(bitwise_acc_ic, 0),
295 ROW_FIELD_EQ(bitwise_ia_byte, 1),
296 ROW_FIELD_EQ(bitwise_ib_byte, 1),
297 ROW_FIELD_EQ(bitwise_ic_byte, 0),
298 ROW_FIELD_EQ(bitwise_tag_a, static_cast<int>(ValueTag::FF)),
299 ROW_FIELD_EQ(bitwise_tag_b, static_cast<int>(ValueTag::U16)),
300 ROW_FIELD_EQ(bitwise_tag_c, static_cast<int>(ValueTag::FF)),
301 ROW_FIELD_EQ(bitwise_ctr, 0),
302 ROW_FIELD_EQ(bitwise_ctr_inv, 0),
303 ROW_FIELD_EQ(bitwise_ctr_min_one_inv, 0),
304 ROW_FIELD_EQ(bitwise_last, 1),
305 // Err Flags
306 ROW_FIELD_EQ(bitwise_sel_tag_ff_err, 1),
307 ROW_FIELD_EQ(bitwise_sel_tag_mismatch_err, 1),
308 ROW_FIELD_EQ(bitwise_err, 1),
309 ROW_FIELD_EQ(bitwise_tag_a_inv, 0),
310 ROW_FIELD_EQ(
311 bitwise_tag_ab_diff_inv,
312 (FF(static_cast<uint8_t>(ValueTag::FF)) - FF(static_cast<uint8_t>(ValueTag::U16))).invert()))));
313}
314
315} // namespace
316} // namespace bb::avm2::tracegen
bitwise_trace.hpp
bb::avm2::TaggedValue::from
static TaggedValue from(T value)
Definition tagged_value.hpp:82
bb::avm2::TaggedValue::from_tag
static TaggedValue from_tag(ValueTag tag, FF value)
Definition tagged_value.cpp:216
bb::avm2::tracegen::AluTraceBuilder::process
void process(const simulation::EventEmitterInterface< simulation::AluEvent >::Container &events, TraceContainer &trace)
Definition alu_trace.cpp:312
bb::avm2::tracegen::TestTraceContainer::as_rows
std::vector< AvmFullRowConstRef > as_rows() const
Definition test_trace_container.cpp:41
builder
AluTraceBuilder builder
Definition alu.test.cpp:123
trace
TestTraceContainer trace
Definition data_copy.test.cpp:59
ROW_FIELD_EQ
#define ROW_FIELD_EQ(field_name, expression)
Definition macros.hpp:15
memory_types.hpp
bb::avm2::simulation::TEST
TEST(EmitUnencryptedLogTest, Basic)
Definition emit_unencrypted_log.test.cpp:20
bb::avm2::FF
AvmFlavorSettings::FF FF
Definition field.hpp:10
std::get
constexpr decltype(auto) get(::tuplet::tuple< T... > &&t) noexcept
Definition tuple.hpp:13
test_trace_container.hpp