Skip to content

Commit de9bbf9

Browse files
rmn-boikormn-boiko
committed
Add all ohers operators
1 parent 6b43e93 commit de9bbf9

File tree

6 files changed

+502
-7
lines changed

6 files changed

+502
-7
lines changed

‎src/ast.rs‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -357,6 +357,7 @@ pub enum Statement {
357357
Continue,
358358
FfMReturn { dst: I64Operand, src: I64Operand, size: I64Operand },
359359
FfReturn { value: FfExpr },
360+
FfExtendI64 { value: I64Operand },
360361
FfMCall {
361362
name: String,
362363
args: Vec<CallArgument>,
@@ -444,13 +445,28 @@ pub enum I64Expr {
444445
Add(Box<I64Expr>, Box<I64Expr>),
445446
Sub(Box<I64Expr>, Box<I64Expr>),
446447
Mul(Box<I64Expr>, Box<I64Expr>),
448+
Div(Box<I64Expr>, Box<I64Expr>),
449+
Pow(Box<I64Expr>, Box<I64Expr>),
450+
Rem(Box<I64Expr>, Box<I64Expr>),
451+
And(Box<I64Expr>, Box<I64Expr>),
452+
Or(Box<I64Expr>, Box<I64Expr>),
447453
Eq(I64Operand, I64Operand),
454+
Neq(I64Operand, I64Operand),
448455
Eqz(I64Operand),
449456
Lt(Box<I64Expr>, Box<I64Expr>),
450457
Lte(Box<I64Expr>, Box<I64Expr>),
451458
Gt(Box<I64Expr>, Box<I64Expr>),
452459
Gte(Box<I64Expr>, Box<I64Expr>),
460+
Shl(Box<I64Expr>, Box<I64Expr>),
461+
Shr(Box<I64Expr>, Box<I64Expr>),
462+
BNot(I64Operand),
463+
BXor(Box<I64Expr>, Box<I64Expr>),
464+
BOr(Box<I64Expr>, Box<I64Expr>),
465+
BAnd(Box<I64Expr>, Box<I64Expr>),
453466
Load(I64Operand),
467+
Return(I64Operand),
468+
MReturn { dst: I64Operand, src: I64Operand, size: I64Operand },
469+
Store(Box<I64Expr>, Box<I64Expr>),
454470
Wrap(Box<FfExpr>),
455471
GetTemplateId(I64Operand),
456472
GetTemplateSignalPosition(I64Operand, I64Operand), // template_id, signal_id

‎src/bin/cvm-compile.rs‎

Lines changed: 82 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -486,15 +486,64 @@ where
486486
i64_expression(ctx, ff, lhs)?;
487487
ctx.code.push(OpCode::OpI64Mul as u8);
488488
}
489+
I64Expr::Div(lhs, rhs) => {
490+
i64_expression(ctx, ff, rhs)?;
491+
i64_expression(ctx, ff, lhs)?;
492+
ctx.code.push(OpCode::OpI64Div as u8);
493+
}
494+
I64Expr::Pow(lhs, rhs) => {
495+
i64_expression(ctx, ff, rhs)?;
496+
i64_expression(ctx, ff, lhs)?;
497+
ctx.code.push(OpCode::OpI64Pow as u8);
498+
}
499+
I64Expr::Rem(lhs, rhs) => {
500+
i64_expression(ctx, ff, rhs)?;
501+
i64_expression(ctx, ff, lhs)?;
502+
ctx.code.push(OpCode::OpI64Rem as u8);
503+
}
504+
I64Expr::And(lhs, rhs) => {
505+
i64_expression(ctx, ff, rhs)?;
506+
i64_expression(ctx, ff, lhs)?;
507+
ctx.code.push(OpCode::OpI64And as u8);
508+
}
509+
I64Expr::Or(lhs, rhs) => {
510+
i64_expression(ctx, ff, rhs)?;
511+
i64_expression(ctx, ff, lhs)?;
512+
ctx.code.push(OpCode::OpI64Or as u8);
513+
}
489514
I64Expr::Eq(lhs, rhs) => {
490515
operand_i64(ctx, rhs);
491516
operand_i64(ctx, lhs);
492517
ctx.code.push(OpCode::OpI64Eq as u8);
493518
}
494-
I64Expr::Eqz(arg) => {
495-
operand_i64(ctx, arg);
519+
I64Expr::Neq(lhs, rhs) => {
520+
operand_i64(ctx, rhs);
521+
operand_i64(ctx, lhs);
522+
ctx.code.push(OpCode::OpI64Neq as u8);
523+
}
524+
I64Expr::Eqz(value) => {
525+
operand_i64(ctx, value);
496526
ctx.code.push(OpCode::OpI64Eqz as u8);
497527
}
528+
I64Expr::BNot(arg) => {
529+
operand_i64(ctx, arg);
530+
ctx.code.push(OpCode::OpI64BNot as u8);
531+
}
532+
I64Expr::BXor(rhs, lhs) => {
533+
i64_expression(ctx, ff, rhs)?;
534+
i64_expression(ctx, ff, lhs)?;
535+
ctx.code.push(OpCode::OpI64BXor as u8);
536+
}
537+
I64Expr::BOr(rhs, lhs) => {
538+
i64_expression(ctx, ff, rhs)?;
539+
i64_expression(ctx, ff, lhs)?;
540+
ctx.code.push(OpCode::OpI64BOr as u8);
541+
}
542+
I64Expr::BAnd(rhs, lhs) => {
543+
i64_expression(ctx, ff, rhs)?;
544+
i64_expression(ctx, ff, lhs)?;
545+
ctx.code.push(OpCode::OpI64BAnd as u8);
546+
}
498547
I64Expr::Lt(lhs, rhs) => {
499548
i64_expression(ctx, ff, rhs)?;
500549
i64_expression(ctx, ff, lhs)?;
@@ -515,10 +564,37 @@ where
515564
i64_expression(ctx, ff, lhs)?;
516565
ctx.code.push(OpCode::OpI64Gte as u8);
517566
}
567+
I64Expr::Shl(lhs, rhs) => {
568+
i64_expression(ctx, ff, rhs)?;
569+
i64_expression(ctx, ff, lhs)?;
570+
ctx.code.push(OpCode::OpI64Shl as u8);
571+
}
572+
I64Expr::Shr(lhs, rhs) => {
573+
i64_expression(ctx, ff, rhs)?;
574+
i64_expression(ctx, ff, lhs)?;
575+
ctx.code.push(OpCode::OpI64Shr as u8);
576+
}
518577
I64Expr::Load(addr) => {
519578
operand_i64(ctx, addr);
520579
ctx.code.push(OpCode::I64Load as u8);
521580
}
581+
I64Expr::Return(addr) => {
582+
operand_i64(ctx, addr);
583+
ctx.code.push(OpCode::I64Return as u8);
584+
}
585+
I64Expr::MReturn { dst, src, size } => {
586+
// Push operands in reverse order so they are popped in correct order
587+
// The VM expects: stack[-2]=dst, stack[-1]=src, stack[0]=size
588+
operand_i64(ctx, dst);
589+
operand_i64(ctx, src);
590+
operand_i64(ctx, size);
591+
ctx.code.push(OpCode::I64MReturn as u8);
592+
},
593+
I64Expr::Store(index, value) => {
594+
i64_expression(ctx, ff, index)?;
595+
i64_expression(ctx, ff, value)?;
596+
ctx.code.push(OpCode::I64Store as u8);
597+
}
522598
I64Expr::Wrap(ff_expr) => {
523599
ff_expression(ctx, ff, ff_expr)?;
524600
ctx.code.push(OpCode::I64WrapFf as u8);
@@ -1062,6 +1138,10 @@ where
10621138
ff_expression(ctx, ff, value)?;
10631139
ctx.code.push(OpCode::FfReturn as u8);
10641140
},
1141+
Statement::FfExtendI64 { value } => {
1142+
operand_i64(ctx, value);
1143+
ctx.code.push(OpCode::FfExtendI64 as u8);
1144+
},
10651145
Statement::FfMCall { name: function_name, args } => {
10661146
// Emit the FfMCall opcode
10671147
ctx.code.push(OpCode::FfMCall as u8);

‎src/lib.rs‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -452,8 +452,12 @@ pub fn calculate_witness_vm2<T: FieldOps>(
452452
circuit.main_template_id, &circuit.templates);
453453

454454
init_signals(
455-
inputs_json, &circuit.field, &circuit.types, &circuit.input_infos,
456-
&mut component_tree)?;
455+
inputs_json,
456+
&circuit.field,
457+
&circuit.types,
458+
&circuit.input_infos,
459+
&mut component_tree,
460+
)?;
457461

458462
#[cfg(feature = "debug_vm2")]
459463
vm2_setup::debug_component_tree(&component_tree, &circuit.templates);

‎src/parser/mod.rs‎

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -817,6 +817,8 @@ fn parse_statement(input: &mut &str) -> ModalResult<Statement> {
817817
|(dst, src, addr, size)| Statement::FfMStoreFromCmpSignal { dst, src, addr, size }),
818818
"ff.return" => preceded(space1, parse_ff_expression)
819819
.map(|value| Statement::FfReturn { value }),
820+
"ff.extend_i64" => preceded(space1, parse_i64_operand)
821+
.map(|value| Statement::FfExtendI64 { value }),
820822
"ff.mcall" => {
821823
|i: &mut &str| {
822824
// Parse the function name prefixed with $
@@ -934,12 +936,26 @@ fn parse_i64_expression(input: &mut &str) -> ModalResult<I64Expr> {
934936
.map(|(op1, op2)| I64Expr::Sub(Box::new(op1), Box::new(op2))),
935937
"i64.mul" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
936938
.map(|(op1, op2)| I64Expr::Mul(Box::new(op1), Box::new(op2))),
939+
"i64.div" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
940+
.map(|(op1, op2)| I64Expr::Div(Box::new(op1), Box::new(op2))),
941+
"i64.pow" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
942+
.map(|(op1, op2)| I64Expr::Pow(Box::new(op1), Box::new(op2))),
943+
"i64.rem" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
944+
.map(|(op1, op2)| I64Expr::Rem(Box::new(op1), Box::new(op2))),
945+
"i64.and" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
946+
.map(|(op1, op2)| I64Expr::And(Box::new(op1), Box::new(op2))),
947+
"i64.or" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
948+
.map(|(op1, op2)| I64Expr::Or(Box::new(op1), Box::new(op2))),
937949
"i64.le" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
938950
.map(|(op1, op2)| I64Expr::Lte(Box::new(op1), Box::new(op2))),
939951
"i64.load" => preceded(space1, parse_i64_operand)
940952
.map(I64Expr::Load),
953+
"i64.store" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
954+
.map(|(op1, op2)| I64Expr::Store(Box::new(op1), Box::new(op2))),
941955
"i64.eq" => (preceded(space1, parse_i64_operand), preceded(space1, parse_i64_operand))
942956
.map(|(op1, op2)| I64Expr::Eq(op1, op2)),
957+
"i64.neq" => (preceded(space1, parse_i64_operand), preceded(space1, parse_i64_operand))
958+
.map(|(op1, op2)| I64Expr::Neq(op1, op2)),
943959
"i64.eqz" => preceded(space1, parse_i64_operand)
944960
.map(I64Expr::Eqz),
945961
"i64.lt" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
@@ -948,8 +964,27 @@ fn parse_i64_expression(input: &mut &str) -> ModalResult<I64Expr> {
948964
.map(|(op1, op2)| I64Expr::Gte(Box::new(op1), Box::new(op2))),
949965
"i64.gt" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
950966
.map(|(op1, op2)| I64Expr::Gt(Box::new(op1), Box::new(op2))),
967+
"i64.shl" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
968+
.map(|(op1, op2)| I64Expr::Shl(Box::new(op1), Box::new(op2))),
969+
"i64.shr" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
970+
.map(|(op1, op2)| I64Expr::Shr(Box::new(op1), Box::new(op2))),
971+
"i64.bnot" => preceded(space1, parse_i64_operand)
972+
.map(I64Expr::BNot),
973+
"i64.bxor" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
974+
.map(|(op1, op2)| I64Expr::BXor(Box::new(op1), Box::new(op2))),
975+
"i64.bor" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
976+
.map(|(op1, op2)| I64Expr::BOr(Box::new(op1), Box::new(op2))),
977+
"i64.band" => (preceded(space1, parse_i64_expression), preceded(space1, parse_i64_expression))
978+
.map(|(op1, op2)| I64Expr::BAnd(Box::new(op1), Box::new(op2))),
951979
"i64.wrap_ff" => preceded(space1, parse_ff_expr)
952980
.map(|expr| I64Expr::Wrap(Box::new(expr))),
981+
"i64.return" => preceded(space1, parse_i64_operand)
982+
.map(I64Expr::Return),
983+
"i64.mreturn" => (
984+
preceded(space1, parse_i64_operand),
985+
preceded(space1, parse_i64_operand),
986+
preceded(space1, parse_i64_operand))
987+
.map(|(op1, op2, op3)| I64Expr::MReturn{ dst: op1, src: op2, size: op3 }),
953988
"get_template_id" => preceded(space1, parse_i64_operand)
954989
.map(I64Expr::GetTemplateId),
955990
"get_template_signal_type" => (

0 commit comments

Comments
 (0)