From 45cafc3a3a670f8e89a01ec728215546a66ded51 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 15 Apr 2025 17:18:05 +0100 Subject: [PATCH 01/21] Unit test to show that the generated SSA is wrong --- Cargo.lock | 1 + .../src/ssa/opt/normalize_value_ids.rs | 2 +- .../noirc_evaluator/src/ssa/parser/mod.rs | 2 +- .../noirc_evaluator/src/ssa/ssa_gen/mod.rs | 6 +- .../src/ssa/ssa_gen/program.rs | 2 +- tooling/ast_fuzzer/Cargo.toml | 1 + tooling/ast_fuzzer/src/program/expr.rs | 97 ++++++++++++++++++- 7 files changed, 100 insertions(+), 11 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 74c95956cc7..3786af358bb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3309,6 +3309,7 @@ dependencies = [ "build-data", "color-eyre", "im", + "insta", "nargo", "noir_fuzzer", "noirc_abi", diff --git a/compiler/noirc_evaluator/src/ssa/opt/normalize_value_ids.rs b/compiler/noirc_evaluator/src/ssa/opt/normalize_value_ids.rs index e815ec76971..dd337e77291 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/normalize_value_ids.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/normalize_value_ids.rs @@ -21,7 +21,7 @@ impl Ssa { /// During normal compilation this is often not the case since prior passes /// may increase the ID counter so that later passes start at different offsets, /// even if they contain the same SSA code. - pub(crate) fn normalize_ids(&mut self) { + pub fn normalize_ids(&mut self) { let mut context = Context::default(); context.populate_functions(&self.functions); for function in self.functions.values_mut() { diff --git a/compiler/noirc_evaluator/src/ssa/parser/mod.rs b/compiler/noirc_evaluator/src/ssa/parser/mod.rs index 38f17ff5d75..6faa356a8a8 100644 --- a/compiler/noirc_evaluator/src/ssa/parser/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/parser/mod.rs @@ -64,7 +64,7 @@ impl Ssa { } } -pub(crate) struct SsaErrorWithSource { +pub struct SsaErrorWithSource { src: String, error: SsaError, } diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs index aec25a4b958..5dd52eff7ae 100644 --- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs @@ -6,7 +6,7 @@ mod value; use acvm::AcirField; use noirc_frontend::hir_def::expr::Constructor; use noirc_frontend::token::FmtStrFragment; -pub(crate) use program::Ssa; +pub use program::Ssa; use context::{Loop, SharedContext}; use iter_extended::{try_vecmap, vecmap}; @@ -45,7 +45,7 @@ pub(crate) const SSA_WORD_SIZE: u32 = 32; /// Generates SSA for the given monomorphized program. /// /// This function will generate the SSA but does not perform any optimizations on it. -pub(crate) fn generate_ssa(program: Program) -> Result { +pub fn generate_ssa(program: Program) -> Result { // see which parameter has call_data/return_data attribute let is_databus = DataBusBuilder::is_databus(&program.main_function_signature); @@ -625,7 +625,7 @@ impl FunctionContext<'_> { /// jmp while_entry() /// while_entry: /// v0 = ... codegen cond ... - /// jmpif v0, then: while_body, else: while_end + /// jmpif v0, then: while_body, else: while_end /// while_body(): /// v3 = ... codegen body ... /// jmp while_entry() diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs index ad52473620d..51c7ac208c7 100644 --- a/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs +++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/program.rs @@ -17,7 +17,7 @@ use super::ValueId; /// Contains the entire SSA representation of the program. #[serde_as] #[derive(Serialize, Deserialize)] -pub(crate) struct Ssa { +pub struct Ssa { #[serde_as(as = "Vec<(_, _)>")] pub(crate) functions: BTreeMap, pub(crate) used_globals: HashMap>, diff --git a/tooling/ast_fuzzer/Cargo.toml b/tooling/ast_fuzzer/Cargo.toml index 016a2db7302..d2815f7112d 100644 --- a/tooling/ast_fuzzer/Cargo.toml +++ b/tooling/ast_fuzzer/Cargo.toml @@ -32,4 +32,5 @@ noir_fuzzer.workspace = true [dev-dependencies] arbtest.workspace = true +insta.workspace = true rand.workspace = true diff --git a/tooling/ast_fuzzer/src/program/expr.rs b/tooling/ast_fuzzer/src/program/expr.rs index 25092e753a1..95a40ebfc3a 100644 --- a/tooling/ast_fuzzer/src/program/expr.rs +++ b/tooling/ast_fuzzer/src/program/expr.rs @@ -209,13 +209,13 @@ pub(crate) fn ident_inner(id: VariableId, mutable: bool, name: Name, typ: Type) } } -/// 32-bit unsigned int literal, used in indexing arrays. -fn positive_int_literal(value: V, typ: Type) -> Expression +/// Integer literal, can be positive or negative depending on type. +fn int_literal(value: V, is_negative: bool, typ: Type) -> Expression where FieldElement: From, { Expression::Literal(Literal::Integer( - SignedField { field: FieldElement::from(value), is_negative: false }, + SignedField { field: FieldElement::from(value), is_negative }, typ, Location::dummy(), )) @@ -223,7 +223,7 @@ where /// 32-bit unsigned int literal, used in indexing arrays. pub(crate) fn u32_literal(value: u32) -> Expression { - positive_int_literal(value, types::U32) + int_literal(value, false, types::U32) } /// Create a variable. @@ -274,7 +274,7 @@ pub(crate) fn index_modulo(idx: Expression, len: u32) -> Expression { /// Take an integer expression and make sure it's no larger than `max_size`. pub(crate) fn range_modulo(lhs: Expression, typ: Type, max_size: usize) -> Expression { - modulo(lhs, positive_int_literal(max_size as u64, typ)) + modulo(lhs, int_literal(max_size as u64, false, typ)) } /// Make a modulo expression. @@ -380,3 +380,90 @@ pub(crate) fn prepend_block(block: Expression, statements: Vec) -> E Expression::Block(result_statements) } + +#[cfg(test)] +mod tests { + use super::{int_literal, range_modulo}; + use nargo::errors::Location; + use noirc_evaluator::{assert_ssa_snapshot, ssa::ssa_gen}; + use noirc_frontend::{ + ast::IntegerBitSize, + monomorphization::ast::{ + Expression, For, FuncId, Function, InlineType, LocalId, Program, Type, + }, + shared::Visibility, + }; + + /// Put a body in a `fn main() { }` and compile it into the initial SSA. + fn generate_ssa_from_body(body: Expression) -> ssa_gen::Ssa { + let func = Function { + id: FuncId(0), + name: "main".to_string(), + parameters: Vec::new(), + body, + return_type: Type::Unit, + unconstrained: false, + inline_type: InlineType::Inline, + func_sig: (Vec::new(), None), + }; + + let sigs = vec![func.func_sig.clone()]; + + let program = Program { + functions: vec![func], + main_function_signature: sigs[0].clone(), + function_signatures: sigs, + return_location: None, + return_visibility: Visibility::Private, + globals: Default::default(), + debug_variables: Default::default(), + debug_functions: Default::default(), + debug_types: Default::default(), + }; + + ssa_gen::generate_ssa(program).unwrap() + } + + #[test] + fn test_modulo_of_negative_literals_in_range() { + let max_size = 5; + let index_type = + Type::Integer(noirc_frontend::shared::Signedness::Signed, IntegerBitSize::SixtyFour); + + let start_range = range_modulo( + int_literal(51675949543456665u64, true, index_type.clone()), + index_type.clone(), + max_size, + ); + let end_range = + range_modulo(int_literal(1u64, true, index_type.clone()), index_type.clone(), max_size); + + let body = Expression::For(For { + index_variable: LocalId(0), + index_name: "idx".to_string(), + index_type, + start_range: Box::new(start_range), + end_range: Box::new(end_range), + block: Box::new(Expression::Break), + start_range_location: Location::dummy(), + end_range_location: Location::dummy(), + }); + + let ssa = generate_ssa_from_body(body); + + assert_ssa_snapshot!(ssa, @r" + acir(inline) fn main f0 { + b0(): + jmp b1(i64 0) + b1(v0: i64): + v3 = lt v0, i64 4 + jmpif v3 then: b2, else: b3 + b2(): + v5 = unchecked_add v0, i64 1 + jmp b3() + b3(): + return + } + "); + } +} From bf10be175a6b6b634c1c57159871d41d76c72aab Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 15 Apr 2025 22:51:47 +0100 Subject: [PATCH 02/21] Move test into own module --- tooling/ast_fuzzer/src/program/expr.rs | 89 +---------------------- tooling/ast_fuzzer/src/program/mod.rs | 17 +---- tooling/ast_fuzzer/src/program/tests.rs | 96 +++++++++++++++++++++++++ 3 files changed, 100 insertions(+), 102 deletions(-) create mode 100644 tooling/ast_fuzzer/src/program/tests.rs diff --git a/tooling/ast_fuzzer/src/program/expr.rs b/tooling/ast_fuzzer/src/program/expr.rs index 95a40ebfc3a..72d5a4a8183 100644 --- a/tooling/ast_fuzzer/src/program/expr.rs +++ b/tooling/ast_fuzzer/src/program/expr.rs @@ -210,7 +210,7 @@ pub(crate) fn ident_inner(id: VariableId, mutable: bool, name: Name, typ: Type) } /// Integer literal, can be positive or negative depending on type. -fn int_literal(value: V, is_negative: bool, typ: Type) -> Expression +pub(crate) fn int_literal(value: V, is_negative: bool, typ: Type) -> Expression where FieldElement: From, { @@ -380,90 +380,3 @@ pub(crate) fn prepend_block(block: Expression, statements: Vec) -> E Expression::Block(result_statements) } - -#[cfg(test)] -mod tests { - use super::{int_literal, range_modulo}; - use nargo::errors::Location; - use noirc_evaluator::{assert_ssa_snapshot, ssa::ssa_gen}; - use noirc_frontend::{ - ast::IntegerBitSize, - monomorphization::ast::{ - Expression, For, FuncId, Function, InlineType, LocalId, Program, Type, - }, - shared::Visibility, - }; - - /// Put a body in a `fn main() { }` and compile it into the initial SSA. - fn generate_ssa_from_body(body: Expression) -> ssa_gen::Ssa { - let func = Function { - id: FuncId(0), - name: "main".to_string(), - parameters: Vec::new(), - body, - return_type: Type::Unit, - unconstrained: false, - inline_type: InlineType::Inline, - func_sig: (Vec::new(), None), - }; - - let sigs = vec![func.func_sig.clone()]; - - let program = Program { - functions: vec![func], - main_function_signature: sigs[0].clone(), - function_signatures: sigs, - return_location: None, - return_visibility: Visibility::Private, - globals: Default::default(), - debug_variables: Default::default(), - debug_functions: Default::default(), - debug_types: Default::default(), - }; - - ssa_gen::generate_ssa(program).unwrap() - } - - #[test] - fn test_modulo_of_negative_literals_in_range() { - let max_size = 5; - let index_type = - Type::Integer(noirc_frontend::shared::Signedness::Signed, IntegerBitSize::SixtyFour); - - let start_range = range_modulo( - int_literal(51675949543456665u64, true, index_type.clone()), - index_type.clone(), - max_size, - ); - let end_range = - range_modulo(int_literal(1u64, true, index_type.clone()), index_type.clone(), max_size); - - let body = Expression::For(For { - index_variable: LocalId(0), - index_name: "idx".to_string(), - index_type, - start_range: Box::new(start_range), - end_range: Box::new(end_range), - block: Box::new(Expression::Break), - start_range_location: Location::dummy(), - end_range_location: Location::dummy(), - }); - - let ssa = generate_ssa_from_body(body); - - assert_ssa_snapshot!(ssa, @r" - acir(inline) fn main f0 { - b0(): - jmp b1(i64 0) - b1(v0: i64): - v3 = lt v0, i64 4 - jmpif v3 then: b2, else: b3 - b2(): - v5 = unchecked_add v0, i64 1 - jmp b3() - b3(): - return - } - "); - } -} diff --git a/tooling/ast_fuzzer/src/program/mod.rs b/tooling/ast_fuzzer/src/program/mod.rs index 8877db80ae5..476911776df 100644 --- a/tooling/ast_fuzzer/src/program/mod.rs +++ b/tooling/ast_fuzzer/src/program/mod.rs @@ -24,6 +24,9 @@ mod scope; mod types; pub(crate) mod visitor; +#[cfg(test)] +mod tests; + /// Generate an arbitrary monomorphized AST. pub fn arb_program(u: &mut Unstructured, config: Config) -> arbitrary::Result { let mut ctx = Context::new(config); @@ -332,17 +335,3 @@ impl std::fmt::Display for DisplayAstAsNoir<'_> { printer.print_program(self.0, f) } } - -#[cfg(test)] -mod tests { - use crate::program::make_name; - - #[test] - fn test_make_name() { - for (i, n) in - [(0, "a"), (1, "b"), (24, "y"), (25, "z"), (26, "ba"), (27, "bb"), (26 * 2 + 3, "cd")] - { - assert_eq!(make_name(i, false), n, "{i} should be {n}"); - } - } -} diff --git a/tooling/ast_fuzzer/src/program/tests.rs b/tooling/ast_fuzzer/src/program/tests.rs new file mode 100644 index 00000000000..d50c6b33c0c --- /dev/null +++ b/tooling/ast_fuzzer/src/program/tests.rs @@ -0,0 +1,96 @@ +use nargo::errors::Location; +use noirc_evaluator::{assert_ssa_snapshot, ssa::ssa_gen}; +use noirc_frontend::{ + ast::IntegerBitSize, + monomorphization::ast::{ + Expression, For, FuncId, Function, InlineType, LocalId, Program, Type, + }, + shared::Visibility, +}; + +#[test] +fn test_make_name() { + use crate::program::make_name; + + for (i, n) in + [(0, "a"), (1, "b"), (24, "y"), (25, "z"), (26, "ba"), (27, "bb"), (26 * 2 + 3, "cd")] + { + assert_eq!(make_name(i, false), n, "{i} should be {n}"); + } +} + +/// Put a body in a `fn main() { }` and compile it into the initial SSA. +fn generate_ssa_from_body(body: Expression) -> ssa_gen::Ssa { + let func = Function { + id: FuncId(0), + name: "main".to_string(), + parameters: Vec::new(), + body, + return_type: Type::Unit, + unconstrained: false, + inline_type: InlineType::Inline, + func_sig: (Vec::new(), None), + }; + + let sigs = vec![func.func_sig.clone()]; + + let program = Program { + functions: vec![func], + main_function_signature: sigs[0].clone(), + function_signatures: sigs, + return_location: None, + return_visibility: Visibility::Private, + globals: Default::default(), + debug_variables: Default::default(), + debug_functions: Default::default(), + debug_types: Default::default(), + }; + + ssa_gen::generate_ssa(program).unwrap() +} + +#[test] +fn test_modulo_of_negative_literals_in_range() { + use super::expr::{int_literal, range_modulo}; + + let max_size = 5; + let index_type = + Type::Integer(noirc_frontend::shared::Signedness::Signed, IntegerBitSize::SixtyFour); + + let start_range = range_modulo( + int_literal(51675949543456665u64, true, index_type.clone()), + index_type.clone(), + max_size, + ); + let end_range = + range_modulo(int_literal(1u64, true, index_type.clone()), index_type.clone(), max_size); + + let body = Expression::For(For { + index_variable: LocalId(0), + index_name: "idx".to_string(), + index_type, + start_range: Box::new(start_range), + end_range: Box::new(end_range), + block: Box::new(Expression::Break), + start_range_location: Location::dummy(), + end_range_location: Location::dummy(), + }); + + let ssa = generate_ssa_from_body(body); + + // The upper bound is -1, represented as a field by subtracting it from 1<<64. + assert_ssa_snapshot!(ssa, @r" + acir(inline) fn main f0 { + b0(): + jmp b1(i64 0) + b1(v0: i64): + v3 = lt v0, i64 18446744073709551615 + jmpif v3 then: b2, else: b3 + b2(): + v5 = unchecked_add v0, i64 1 + jmp b3() + b3(): + return + } + "); +} From 9673e82a32f295fc774bb4a4e4f90df0cbb1ff5a Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 15 Apr 2025 23:39:43 +0100 Subject: [PATCH 03/21] Example of the overflow as a test in unrolling --- .../src/ssa/ir/instruction/binary.rs | 10 ++++ .../noirc_evaluator/src/ssa/opt/unrolling.rs | 47 +++++++++++++------ 2 files changed, 43 insertions(+), 14 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs index 08fc897f99c..5c5347c2006 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs @@ -375,4 +375,14 @@ mod test { assert!(BinaryOp::Shr.get_i128_function()(1, 128).is_none()); assert!(BinaryOp::Shl.get_i128_function()(1, 128).is_none()); } + + #[test] + fn test_plus_minus_one_as_field() { + for (i, u) in [(-1i64, u64::MAX), (-2i64, u64::MAX - 1), (1i64, 1u64)] { + let i: i128 = i.into(); + let f = convert_signed_integer_to_field_element(i, 64); + assert_eq!(f.to_u128(), u as u128); + assert_eq!(i, try_convert_field_element_to_signed_integer(f, 64).unwrap()); + } + } } diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs index 935588e2b13..8db5471567f 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs @@ -1197,6 +1197,15 @@ mod tests { assert!(stats.is_small()); } + #[test] + fn test_boilerplate_stats_i64() { + // Looping from 0..-1, but + let ssa = brillig_unroll_test_case_6470_with_params("i64", "0", "18446744073709551615"); + let stats = loop0_stats(&ssa); + assert_eq!(stats.unrolled_instructions(), 0); + assert_eq!(stats.iterations, 0); + } + #[test] fn test_boilerplate_stats_6470() { let ssa = brillig_unroll_test_case_6470(3); @@ -1393,30 +1402,36 @@ mod tests { /// removing the `unconstrained` from the `main` function and /// compiling the program with `nargo --test-program . compile --show-ssa`. fn brillig_unroll_test_case() -> Ssa { - let src = " + brillig_unroll_test_case_with_params("u32", "0", "4") + } + + fn brillig_unroll_test_case_with_params(idx_type: &str, lower: &str, upper: &str) -> Ssa { + let src = format!( + " // After `static_assert` and `assert_constant`: - brillig(inline) fn main f0 { + brillig(inline) fn main f0 {{ b0(v0: u32): v2 = allocate -> &mut u32 store u32 0 at v2 - jmp b1(u32 0) - b1(v1: u32): - v5 = lt v1, u32 4 + jmp b1({idx_type} {lower}) + b1(v1: {idx_type}): + v5 = lt v1, {idx_type} {upper} jmpif v5 then: b3, else: b2 b3(): v8 = load v2 -> u32 v9 = add v8, v1 store v9 at v2 - v11 = add v1, u32 1 + v11 = add v1, {idx_type} 1 jmp b1(v11) b2(): v6 = load v2 -> u32 v7 = eq v6, v0 constrain v6 == v0 return - } - "; - Ssa::from_str(src).unwrap() + }} + " + ); + Ssa::from_str(&src).unwrap() } /// Test case from #6470: @@ -1433,6 +1448,10 @@ mod tests { /// ``` /// The `num_iterations` parameter can be used to make it more costly to inline. fn brillig_unroll_test_case_6470(num_iterations: usize) -> Ssa { + brillig_unroll_test_case_6470_with_params("u32", "0", &format!("{num_iterations}")) + } + + fn brillig_unroll_test_case_6470_with_params(idx_type: &str, lower: &str, upper: &str) -> Ssa { let src = format!( " // After `static_assert` and `assert_constant`: @@ -1443,18 +1462,18 @@ mod tests { inc_rc v3 v4 = allocate -> &mut [u64; 6] store v3 at v4 - jmp b1(u32 0) - b1(v1: u32): - v7 = lt v1, u32 {num_iterations} + jmp b1({idx_type} {lower}) + b1(v1: {idx_type}): + v7 = lt v1, {idx_type} {upper} jmpif v7 then: b3, else: b2 b3(): v9 = load v4 -> [u64; 6] v10 = array_get v0, index v1 -> u64 v12 = add v10, u64 1 v13 = array_set v9, index v1, value v12 - v15 = add v1, u32 1 + v15 = add v1, {idx_type} 1 store v13 at v4 - v16 = add v1, u32 1 // duplicate + v16 = add v1, {idx_type} 1 // duplicate jmp b1(v16) b2(): v8 = load v4 -> [u64; 6] From 475f0c85895d721ca6333ae35e2f69dfeec50d95 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 15 Apr 2025 23:59:12 +0100 Subject: [PATCH 04/21] Use i128 in unrolling --- .../src/ssa/ir/instruction/binary.rs | 7 ++- .../src/ssa/opt/loop_invariant.rs | 5 ++- .../noirc_evaluator/src/ssa/opt/unrolling.rs | 44 +++++++++++-------- 3 files changed, 35 insertions(+), 21 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs index 5c5347c2006..122d53d60b4 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs @@ -202,7 +202,10 @@ pub(crate) fn eval_constant_binary_op( /// Values in the range `[0, 2^(bit_size-1))` are interpreted as positive integers /// /// Values in the range `[2^(bit_size-1), 2^bit_size)` are interpreted as negative integers. -fn try_convert_field_element_to_signed_integer(field: FieldElement, bit_size: u32) -> Option { +pub(crate) fn try_convert_field_element_to_signed_integer( + field: FieldElement, + bit_size: u32, +) -> Option { let unsigned_int = truncate(field.try_into_u128()?, bit_size); let max_positive_value = 1 << (bit_size - 1); @@ -219,7 +222,7 @@ fn try_convert_field_element_to_signed_integer(field: FieldElement, bit_size: u3 Some(signed_int) } -fn convert_signed_integer_to_field_element(int: i128, bit_size: u32) -> FieldElement { +pub(crate) fn convert_signed_integer_to_field_element(int: i128, bit_size: u32) -> FieldElement { if int >= 0 { FieldElement::from(int) } else { diff --git a/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs index a4488cfd90a..6e067a9b04e 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs @@ -59,7 +59,7 @@ use crate::ssa::{ function_inserter::FunctionInserter, instruction::{ Binary, BinaryOp, ConstrainError, Instruction, InstructionId, - binary::eval_constant_binary_op, + binary::{convert_signed_integer_to_field_element, eval_constant_binary_op}, }, post_order::PostOrder, types::{NumericType, Type}, @@ -367,6 +367,9 @@ impl<'f> LoopInvariantContext<'f> { fn set_induction_var_bounds(&mut self, loop_: &Loop, current_loop: bool) { let bounds = loop_.get_const_bounds(self.inserter.function, self.pre_header()); if let Some((lower_bound, upper_bound)) = bounds { + let bit_size = NumericType::length_type().bit_size(); + let lower_bound = convert_signed_integer_to_field_element(lower_bound, bit_size); + let upper_bound = convert_signed_integer_to_field_element(upper_bound, bit_size); let induction_variable = loop_.get_induction_variable(self.inserter.function); let induction_variable = self.inserter.resolve(induction_variable); if current_loop { diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs index 8db5471567f..73fca278c26 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs @@ -20,7 +20,7 @@ //! only used by Brillig bytecode. use std::collections::BTreeSet; -use acvm::{FieldElement, acir::AcirField}; +use acvm::acir::AcirField; use im::HashSet; use crate::{ @@ -34,8 +34,12 @@ use crate::{ dom::DominatorTree, function::Function, function_inserter::{ArrayCache, FunctionInserter}, - instruction::{Binary, BinaryOp, Instruction, InstructionId, TerminatorInstruction}, + instruction::{ + Binary, BinaryOp, Instruction, InstructionId, TerminatorInstruction, + binary::try_convert_field_element_to_signed_integer, + }, post_order::PostOrder, + types::NumericType, value::ValueId, }, ssa_gen::Ssa, @@ -282,6 +286,17 @@ impl Loop { Self { header, back_edge_start, blocks } } + /// Handle negative values represented as fields. + fn get_const_as_i128(function: &Function, id: ValueId) -> Option { + let (value, typ) = function.dfg.get_numeric_constant_with_type(id)?; + if matches!(typ, NumericType::NativeField) { + // Shouldn't happen, as fields don't have meaningful ordering. + value.try_into_i128() + } else { + try_convert_field_element_to_signed_integer(value, typ.bit_size()) + } + } + /// Find the lower bound of the loop in the pre-header and return it /// if it's a numeric constant, which it will be if the previous SSA /// steps managed to inline it. @@ -296,13 +311,9 @@ impl Loop { /// v5 = lt v1, u32 4 /// jmpif v5 then: b3, else: b2 /// ``` - fn get_const_lower_bound( - &self, - function: &Function, - pre_header: BasicBlockId, - ) -> Option { + fn get_const_lower_bound(&self, function: &Function, pre_header: BasicBlockId) -> Option { let jump_value = get_induction_variable(function, pre_header).ok()?; - function.dfg.get_numeric_constant(jump_value) + Self::get_const_as_i128(function, jump_value) } /// Find the upper bound of the loop in the loop header and return it @@ -319,7 +330,7 @@ impl Loop { /// v5 = lt v1, u32 4 // Upper bound /// jmpif v5 then: b3, else: b2 /// ``` - fn get_const_upper_bound(&self, function: &Function) -> Option { + fn get_const_upper_bound(&self, function: &Function) -> Option { let block = &function.dfg[self.header]; let instructions = block.instructions(); if instructions.is_empty() { @@ -336,14 +347,14 @@ impl Loop { match &function.dfg[instructions[0]] { Instruction::Binary(Binary { lhs: _, operator: BinaryOp::Lt, rhs }) => { - function.dfg.get_numeric_constant(*rhs) + Self::get_const_as_i128(function, *rhs) } Instruction::Binary(Binary { lhs: _, operator: BinaryOp::Eq, rhs }) => { // `for i in 0..1` is turned into: // b1(v0: u32): // v12 = eq v0, u32 0 // jmpif v12 then: b3, else: b2 - function.dfg.get_numeric_constant(*rhs).map(|c| c + FieldElement::one()) + Self::get_const_as_i128(function, *rhs).map(|c| c + 1) } other => panic!("Unexpected instruction in header: {other:?}"), } @@ -354,7 +365,7 @@ impl Loop { &self, function: &Function, pre_header: BasicBlockId, - ) -> Option<(FieldElement, FieldElement)> { + ) -> Option<(i128, i128)> { let lower = self.get_const_lower_bound(function, pre_header)?; let upper = self.get_const_upper_bound(function)?; Some((lower, upper)) @@ -678,8 +689,6 @@ impl Loop { ) -> Option { let pre_header = self.get_pre_header(function, cfg).ok()?; let (lower, upper) = self.get_const_bounds(function, pre_header)?; - let lower = lower.try_to_u64()?; - let upper = upper.try_to_u64()?; let refs = self.find_pre_header_reference_values(function, cfg)?; let (loads, stores) = self.count_loads_and_stores(function, &refs); @@ -687,7 +696,7 @@ impl Loop { let all_instructions = self.count_all_instructions(function); Some(BoilerplateStats { - iterations: (upper - lower) as usize, + iterations: (upper - lower).max(0) as usize, loads, stores, increments, @@ -1029,7 +1038,6 @@ fn is_new_size_ok(orig_size: usize, new_size: usize, max_incr_pct: i32) -> bool #[cfg(test)] mod tests { - use acvm::FieldElement; use test_case::test_case; use crate::assert_ssa_snapshot; @@ -1160,8 +1168,8 @@ mod tests { let (lower, upper) = loop_.get_const_bounds(function, pre_header).expect("bounds are numeric const"); - assert_eq!(lower, FieldElement::from(0u32)); - assert_eq!(upper, FieldElement::from(4u32)); + assert_eq!(lower, 0); + assert_eq!(upper, 4); } #[test] From db8f391d381aeed4dc5ea8381fd9ee31f5ea2b73 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Wed, 16 Apr 2025 00:09:13 +0100 Subject: [PATCH 05/21] Integration test to show that negative ranges are handled --- .../execution_success/regression_8009/Nargo.toml | 7 +++++++ .../execution_success/regression_8009/Prover.toml | 3 +++ .../execution_success/regression_8009/src/main.nr | 9 +++++++++ tooling/ast_fuzzer/src/program/.tests.rs.pending-snap | 3 +++ tooling/ast_fuzzer/src/program/tests.rs | 1 + 5 files changed, 23 insertions(+) create mode 100644 test_programs/execution_success/regression_8009/Nargo.toml create mode 100644 test_programs/execution_success/regression_8009/Prover.toml create mode 100644 test_programs/execution_success/regression_8009/src/main.nr create mode 100644 tooling/ast_fuzzer/src/program/.tests.rs.pending-snap diff --git a/test_programs/execution_success/regression_8009/Nargo.toml b/test_programs/execution_success/regression_8009/Nargo.toml new file mode 100644 index 00000000000..9c1e28f204c --- /dev/null +++ b/test_programs/execution_success/regression_8009/Nargo.toml @@ -0,0 +1,7 @@ +[package] +name = "regression_8009" +version = "0.1.0" +type = "bin" +authors = [""] + +[dependencies] diff --git a/test_programs/execution_success/regression_8009/Prover.toml b/test_programs/execution_success/regression_8009/Prover.toml new file mode 100644 index 00000000000..35445cec952 --- /dev/null +++ b/test_programs/execution_success/regression_8009/Prover.toml @@ -0,0 +1,3 @@ +start = -51675949543456665 +end = -1 +return = 0 diff --git a/test_programs/execution_success/regression_8009/src/main.nr b/test_programs/execution_success/regression_8009/src/main.nr new file mode 100644 index 00000000000..770b591df71 --- /dev/null +++ b/test_programs/execution_success/regression_8009/src/main.nr @@ -0,0 +1,9 @@ +unconstrained fn main(start: i64, end: i64) -> pub u32 { + let start = (start % 5); + let end = (end % 5); + let mut sum = 0; + for i in start .. end { + sum += 1; + } + sum +} \ No newline at end of file diff --git a/tooling/ast_fuzzer/src/program/.tests.rs.pending-snap b/tooling/ast_fuzzer/src/program/.tests.rs.pending-snap new file mode 100644 index 00000000000..0ee9a245394 --- /dev/null +++ b/tooling/ast_fuzzer/src/program/.tests.rs.pending-snap @@ -0,0 +1,3 @@ +{"run_id":"1744758075-227380000","line":83,"new":{"module_name":"noir_ast_fuzzer__program__tests","snapshot_name":"modulo_of_negative_literals_in_range","metadata":{"source":"tooling/ast_fuzzer/src/program/tests.rs","assertion_line":83,"expression":"mut_ssa"},"snapshot":"acir(inline) fn main f0 {\n b0():\n jmp b1(i64 18446744073709551612)\n b1(v0: i64):\n v3 = lt v0, i64 18446744073709551615\n jmpif v3 then: b2, else: b3\n b2():\n v5 = unchecked_add v0, i64 1\n jmp b3()\n b3():\n return\n}"},"old":{"module_name":"noir_ast_fuzzer__program__tests","metadata":{},"snapshot":"acir(inline) fn main f0 {\n b0():\n jmp b1(i64 0)\n b1(v0: i64):\n v3 = lt v0, i64 18446744073709551615\n jmpif v3 then: b2, else: b3\n b2():\n v5 = unchecked_add v0, i64 1\n jmp b3()\n b3():\n return\n}"}} +{"run_id":"1744758104-705122000","line":83,"new":{"module_name":"noir_ast_fuzzer__program__tests","snapshot_name":"modulo_of_negative_literals_in_range","metadata":{"source":"tooling/ast_fuzzer/src/program/tests.rs","assertion_line":83,"expression":"mut_ssa"},"snapshot":"acir(inline) fn main f0 {\n b0():\n jmp b1(i64 18446744073709551614)\n b1(v0: i64):\n v3 = lt v0, i64 18446744073709551615\n jmpif v3 then: b2, else: b3\n b2():\n v5 = unchecked_add v0, i64 1\n jmp b3()\n b3():\n return\n}"},"old":{"module_name":"noir_ast_fuzzer__program__tests","metadata":{},"snapshot":"acir(inline) fn main f0 {\n b0():\n jmp b1(i64 0)\n b1(v0: i64):\n v3 = lt v0, i64 18446744073709551615\n jmpif v3 then: b2, else: b3\n b2():\n v5 = unchecked_add v0, i64 1\n jmp b3()\n b3():\n return\n}"}} +{"run_id":"1744758124-768965000","line":83,"new":null,"old":null} diff --git a/tooling/ast_fuzzer/src/program/tests.rs b/tooling/ast_fuzzer/src/program/tests.rs index d50c6b33c0c..0c85debab07 100644 --- a/tooling/ast_fuzzer/src/program/tests.rs +++ b/tooling/ast_fuzzer/src/program/tests.rs @@ -49,6 +49,7 @@ fn generate_ssa_from_body(body: Expression) -> ssa_gen::Ssa { ssa_gen::generate_ssa(program).unwrap() } +/// Test the SSA we get when we use negative range literals with modulo. #[test] fn test_modulo_of_negative_literals_in_range() { use super::expr::{int_literal, range_modulo}; From 0b5bf80f337a27146ca8d29e08aa64e5b341ffa5 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Wed, 16 Apr 2025 00:17:43 +0100 Subject: [PATCH 06/21] Add snapshot --- .../regression_8009/stdout.txt | 1 + .../src/program/.tests.rs.pending-snap | 3 - ...ig_false_inliner_-9223372036854775808.snap | 62 +++++++++++++++++++ ..._tests__force_brillig_false_inliner_0.snap | 62 +++++++++++++++++++ ...lig_false_inliner_9223372036854775807.snap | 62 +++++++++++++++++++ ...lig_true_inliner_-9223372036854775808.snap | 62 +++++++++++++++++++ ...__tests__force_brillig_true_inliner_0.snap | 62 +++++++++++++++++++ ...llig_true_inliner_9223372036854775807.snap | 62 +++++++++++++++++++ 8 files changed, 373 insertions(+), 3 deletions(-) create mode 100644 test_programs/execution_success/regression_8009/stdout.txt delete mode 100644 tooling/ast_fuzzer/src/program/.tests.rs.pending-snap create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_0.snap create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_9223372036854775807.snap create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_0.snap create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_9223372036854775807.snap diff --git a/test_programs/execution_success/regression_8009/stdout.txt b/test_programs/execution_success/regression_8009/stdout.txt new file mode 100644 index 00000000000..4620f639006 --- /dev/null +++ b/test_programs/execution_success/regression_8009/stdout.txt @@ -0,0 +1 @@ +[regression_8009] Circuit output: Field(0) diff --git a/tooling/ast_fuzzer/src/program/.tests.rs.pending-snap b/tooling/ast_fuzzer/src/program/.tests.rs.pending-snap deleted file mode 100644 index 0ee9a245394..00000000000 --- a/tooling/ast_fuzzer/src/program/.tests.rs.pending-snap +++ /dev/null @@ -1,3 +0,0 @@ -{"run_id":"1744758075-227380000","line":83,"new":{"module_name":"noir_ast_fuzzer__program__tests","snapshot_name":"modulo_of_negative_literals_in_range","metadata":{"source":"tooling/ast_fuzzer/src/program/tests.rs","assertion_line":83,"expression":"mut_ssa"},"snapshot":"acir(inline) fn main f0 {\n b0():\n jmp b1(i64 18446744073709551612)\n b1(v0: i64):\n v3 = lt v0, i64 18446744073709551615\n jmpif v3 then: b2, else: b3\n b2():\n v5 = unchecked_add v0, i64 1\n jmp b3()\n b3():\n return\n}"},"old":{"module_name":"noir_ast_fuzzer__program__tests","metadata":{},"snapshot":"acir(inline) fn main f0 {\n b0():\n jmp b1(i64 0)\n b1(v0: i64):\n v3 = lt v0, i64 18446744073709551615\n jmpif v3 then: b2, else: b3\n b2():\n v5 = unchecked_add v0, i64 1\n jmp b3()\n b3():\n return\n}"}} -{"run_id":"1744758104-705122000","line":83,"new":{"module_name":"noir_ast_fuzzer__program__tests","snapshot_name":"modulo_of_negative_literals_in_range","metadata":{"source":"tooling/ast_fuzzer/src/program/tests.rs","assertion_line":83,"expression":"mut_ssa"},"snapshot":"acir(inline) fn main f0 {\n b0():\n jmp b1(i64 18446744073709551614)\n b1(v0: i64):\n v3 = lt v0, i64 18446744073709551615\n jmpif v3 then: b2, else: b3\n b2():\n v5 = unchecked_add v0, i64 1\n jmp b3()\n b3():\n return\n}"},"old":{"module_name":"noir_ast_fuzzer__program__tests","metadata":{},"snapshot":"acir(inline) fn main f0 {\n b0():\n jmp b1(i64 0)\n b1(v0: i64):\n v3 = lt v0, i64 18446744073709551615\n jmpif v3 then: b2, else: b3\n b2():\n v5 = unchecked_add v0, i64 1\n jmp b3()\n b3():\n return\n}"}} -{"run_id":"1744758124-768965000","line":83,"new":null,"old":null} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..5347f495849 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -0,0 +1,62 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "start", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" + }, + { + "name": "end", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "file_map": { + "50": { + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_0.snap new file mode 100644 index 00000000000..5347f495849 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_0.snap @@ -0,0 +1,62 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "start", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" + }, + { + "name": "end", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "file_map": { + "50": { + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..5347f495849 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -0,0 +1,62 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "start", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" + }, + { + "name": "end", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "file_map": { + "50": { + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..5347f495849 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -0,0 +1,62 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "start", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" + }, + { + "name": "end", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "file_map": { + "50": { + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_0.snap new file mode 100644 index 00000000000..5347f495849 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_0.snap @@ -0,0 +1,62 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "start", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" + }, + { + "name": "end", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "file_map": { + "50": { + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..5347f495849 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -0,0 +1,62 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [ + { + "name": "start", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" + }, + { + "name": "end", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" + } + ], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "file_map": { + "50": { + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} From b2c510c85258f47e0c8488a63569b8daec0e603d Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Wed, 16 Apr 2025 00:18:10 +0100 Subject: [PATCH 07/21] Hint at the env var for stdout.txt --- tooling/nargo_cli/tests/execute.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tooling/nargo_cli/tests/execute.rs b/tooling/nargo_cli/tests/execute.rs index 8839441de44..6948d7c5337 100644 --- a/tooling/nargo_cli/tests/execute.rs +++ b/tooling/nargo_cli/tests/execute.rs @@ -143,6 +143,11 @@ mod tests { println!( "stdout does not match expected output. Expected:\n{expected_stdout}\n\nActual:\n{stdout}" ); + if expected_stdout.is_empty() && !stdout_path.exists() { + println!( + "Hint: set the OVERWRITE_TEST_OUTPUT env var to establish a stdout.txt" + ) + } assert_eq!(stdout, expected_stdout); } } From 0e92d3ac8a536dc2fa8df4f2da05014849ce00df Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Wed, 16 Apr 2025 00:25:10 +0100 Subject: [PATCH 08/21] Format Noir test --- test_programs/execution_success/regression_8009/src/main.nr | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test_programs/execution_success/regression_8009/src/main.nr b/test_programs/execution_success/regression_8009/src/main.nr index 770b591df71..a412f81fd71 100644 --- a/test_programs/execution_success/regression_8009/src/main.nr +++ b/test_programs/execution_success/regression_8009/src/main.nr @@ -2,8 +2,8 @@ unconstrained fn main(start: i64, end: i64) -> pub u32 { let start = (start % 5); let end = (end % 5); let mut sum = 0; - for i in start .. end { + for i in start..end { sum += 1; } sum -} \ No newline at end of file +} From 9cd524c02dfc5c84446ab84b19fe9ec4414f9aaa Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Wed, 16 Apr 2025 00:29:39 +0100 Subject: [PATCH 09/21] Add test for non-empty negative range --- .../noirc_evaluator/src/ssa/opt/unrolling.rs | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs index 73fca278c26..38f8dbbf606 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs @@ -1206,12 +1206,24 @@ mod tests { } #[test] - fn test_boilerplate_stats_i64() { - // Looping from 0..-1, but + fn test_boilerplate_stats_i64_empty() { + // Looping 0..-1, which should be 0 iterations. let ssa = brillig_unroll_test_case_6470_with_params("i64", "0", "18446744073709551615"); let stats = loop0_stats(&ssa); - assert_eq!(stats.unrolled_instructions(), 0); assert_eq!(stats.iterations, 0); + assert_eq!(stats.unrolled_instructions(), 0); + } + + #[test] + fn test_boilerplate_stats_i64_non_empty() { + // Looping -4..-1, which should be 3 iterations. + let ssa = brillig_unroll_test_case_6470_with_params( + "i64", + "18446744073709551612", + "18446744073709551615", + ); + let stats = loop0_stats(&ssa); + assert_eq!(stats.iterations, 3); } #[test] From f1299c53f4a49d977bca4c8207094f7a9ddf3db3 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 13:24:08 +0100 Subject: [PATCH 10/21] fix: Don't skip for loops with negative literal ranges (#8103) --- compiler/noirc_evaluator/src/ssa/ir/dfg.rs | 14 +- .../noirc_evaluator/src/ssa/ir/integer.rs | 122 ++++++++++++++++++ compiler/noirc_evaluator/src/ssa/ir/mod.rs | 1 + .../src/ssa/opt/loop_invariant.rs | 48 +++---- .../noirc_evaluator/src/ssa/opt/unrolling.rs | 56 ++++---- .../noirc_evaluator/src/ssa/ssa_gen/mod.rs | 9 +- .../regression_8011/Nargo.toml | 6 + .../regression_8011/Prover.toml | 1 + .../regression_8011/src/main.nr | 26 ++++ .../regression_8011/stdout.txt | 1 + ...ig_false_inliner_-9223372036854775808.snap | 4 +- ..._tests__force_brillig_false_inliner_0.snap | 4 +- ...lig_false_inliner_9223372036854775807.snap | 4 +- ...lig_true_inliner_-9223372036854775808.snap | 4 +- ...__tests__force_brillig_true_inliner_0.snap | 4 +- ...llig_true_inliner_9223372036854775807.snap | 4 +- ...ig_false_inliner_-9223372036854775808.snap | 43 ++++++ ..._tests__force_brillig_false_inliner_0.snap | 43 ++++++ ...lig_false_inliner_9223372036854775807.snap | 43 ++++++ ...lig_true_inliner_-9223372036854775808.snap | 43 ++++++ ...__tests__force_brillig_true_inliner_0.snap | 43 ++++++ ...llig_true_inliner_9223372036854775807.snap | 43 ++++++ 22 files changed, 494 insertions(+), 72 deletions(-) create mode 100644 compiler/noirc_evaluator/src/ssa/ir/integer.rs create mode 100644 test_programs/execution_success/regression_8011/Nargo.toml create mode 100644 test_programs/execution_success/regression_8011/Prover.toml create mode 100644 test_programs/execution_success/regression_8011/src/main.nr create mode 100644 test_programs/execution_success/regression_8011/stdout.txt create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_0.snap create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_9223372036854775807.snap create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_0.snap create mode 100644 tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_9223372036854775807.snap diff --git a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs index dfef0ed5bb1..fbd05470714 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs @@ -12,6 +12,7 @@ use super::{ instruction::{ Instruction, InstructionId, InstructionResultType, Intrinsic, TerminatorInstruction, }, + integer::IntegerConstant, map::DenseMap, types::{NumericType, Type}, value::{Value, ValueId, ValueMapping}, @@ -582,13 +583,22 @@ impl DataFlowGraph { } /// Returns the field element represented by this value if it is a numeric constant. - /// Returns None if the given value is not a numeric constant. + /// Returns `None` if the given value is not a numeric constant. + /// + /// Use `get_integer_constant` if the underlying values need to be compared as signed integers. pub(crate) fn get_numeric_constant(&self, value: ValueId) -> Option { self.get_numeric_constant_with_type(value).map(|(value, _typ)| value) } + /// Similar to `get_numeric_constant` but returns the value as a signed or unsigned integer. + /// Returns `None` if the given value is not an integer constant. + pub(crate) fn get_integer_constant(&self, value: ValueId) -> Option { + self.get_numeric_constant_with_type(value) + .and_then(|(f, t)| IntegerConstant::from_numeric_constant(f, t)) + } + /// Returns the field element and type represented by this value if it is a numeric constant. - /// Returns None if the given value is not a numeric constant. + /// Returns `None` if the given value is not a numeric constant. pub(crate) fn get_numeric_constant_with_type( &self, value: ValueId, diff --git a/compiler/noirc_evaluator/src/ssa/ir/integer.rs b/compiler/noirc_evaluator/src/ssa/ir/integer.rs new file mode 100644 index 00000000000..38ff4dbbd39 --- /dev/null +++ b/compiler/noirc_evaluator/src/ssa/ir/integer.rs @@ -0,0 +1,122 @@ +use std::cmp::Ordering; + +use acvm::{AcirField, FieldElement}; +use num_traits::Zero; + +use super::{instruction::binary, types::NumericType}; + +/// A `Signed` or `Unsigned` value of a `Value::NumericConstant`, converted to 128 bits. +/// +/// This type can be used in loops and other instances where values have to be compared, +/// with correct handling of negative values. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum IntegerConstant { + Signed { value: i128, bit_size: u32 }, + Unsigned { value: u128, bit_size: u32 }, +} + +impl IntegerConstant { + pub(crate) fn from_numeric_constant(field: FieldElement, typ: NumericType) -> Option { + match typ { + NumericType::Signed { bit_size } => { + binary::try_convert_field_element_to_signed_integer(field, bit_size) + .map(|value| Self::Signed { value, bit_size }) + } + NumericType::Unsigned { bit_size } => { + Some(Self::Unsigned { value: field.to_u128(), bit_size }) + } + NumericType::NativeField => None, + } + } + + /// Convert back into a field. + pub(crate) fn into_numeric_constant(self) -> (FieldElement, NumericType) { + match self { + Self::Signed { value, bit_size } => ( + binary::convert_signed_integer_to_field_element(value, bit_size), + NumericType::signed(bit_size), + ), + Self::Unsigned { value, bit_size } => { + (FieldElement::from(value), NumericType::unsigned(bit_size)) + } + } + } + + /// Reduce two constants into a result by applying functions on them if their signedness matches. + pub(crate) fn reduce( + self, + other: Self, + s: impl Fn(i128, i128) -> T, + u: impl Fn(u128, u128) -> T, + ) -> Option { + match (self, other) { + (Self::Signed { value: a, .. }, Self::Signed { value: b, .. }) => Some(s(a, b)), + (Self::Unsigned { value: a, .. }, Self::Unsigned { value: b, .. }) => Some(u(a, b)), + _ => None, + } + } + + /// Apply functions on signed/unsigned values. + pub(crate) fn apply(&self, s: impl Fn(i128) -> T, u: impl Fn(u128) -> T) -> T { + match self { + Self::Signed { value, .. } => s(*value), + Self::Unsigned { value, .. } => u(*value), + } + } + + /// Increment the value by 1, saturating at the maximum value. + pub(crate) fn inc(self) -> Self { + match self { + Self::Signed { value, bit_size } => { + Self::Signed { value: value.saturating_add(1), bit_size } + } + Self::Unsigned { value, bit_size } => { + Self::Unsigned { value: value.saturating_add(1), bit_size } + } + } + } + + /// Decrement the value by 1, saturating at the minimum value. + pub(crate) fn dec(self) -> Self { + match self { + Self::Signed { value, bit_size } => { + Self::Signed { value: value.saturating_sub(1), bit_size } + } + Self::Unsigned { value, bit_size } => { + Self::Unsigned { value: value.saturating_sub(1), bit_size } + } + } + } + + pub(crate) fn is_zero(&self) -> bool { + match self { + Self::Signed { value, .. } => value.is_zero(), + Self::Unsigned { value, .. } => value.is_zero(), + } + } +} + +impl PartialOrd for IntegerConstant { + fn partial_cmp(&self, other: &Self) -> Option { + match (self, other) { + (Self::Signed { value: a, .. }, Self::Signed { value: b, .. }) => a.partial_cmp(b), + (Self::Signed { value: a, .. }, Self::Unsigned { value: b, .. }) => { + if a.is_negative() || *b > i128::MAX as u128 { + Some(Ordering::Less) + } else { + let a: u128 = (*a).try_into().ok()?; + a.partial_cmp(b) + } + } + (Self::Unsigned { value: a, .. }, Self::Signed { value: b, .. }) => { + if b.is_negative() || *a > i128::MAX as u128 { + Some(Ordering::Less) + } else { + let b: u128 = (*b).try_into().ok()?; + a.partial_cmp(&b) + } + } + (Self::Unsigned { value: a, .. }, Self::Unsigned { value: b, .. }) => a.partial_cmp(b), + } + } +} diff --git a/compiler/noirc_evaluator/src/ssa/ir/mod.rs b/compiler/noirc_evaluator/src/ssa/ir/mod.rs index fefaaf4cb5d..3c750d12b7e 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/mod.rs @@ -6,6 +6,7 @@ pub(crate) mod dom; pub mod function; pub(crate) mod function_inserter; pub mod instruction; +pub(crate) mod integer; pub mod map; pub(crate) mod post_order; pub(crate) mod printer; diff --git a/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs index 10619fe2aeb..c0e7f91f6c1 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs @@ -59,8 +59,9 @@ use crate::ssa::{ function_inserter::FunctionInserter, instruction::{ Binary, BinaryOp, ConstrainError, Instruction, InstructionId, - binary::{convert_signed_integer_to_field_element, eval_constant_binary_op}, + binary::eval_constant_binary_op, }, + integer::IntegerConstant, post_order::PostOrder, types::{NumericType, Type}, value::{Value, ValueId}, @@ -152,11 +153,11 @@ struct LoopInvariantContext<'f> { // This map is expected to only ever contain a singular value. // However, we store it in a map in order to match the definition of // `outer_induction_variables` as both maps share checks for evaluating binary operations. - current_induction_variables: HashMap, + current_induction_variables: HashMap, // Maps outer loop induction variable -> fixed lower and upper loop bound // This will be used by inner loops to determine whether they // have safe operations reliant upon an outer loop's maximum induction variable. - outer_induction_variables: HashMap, + outer_induction_variables: HashMap, // This context struct processes runs across all loops. // This stores the current loop's pre-header block. // It is wrapped in an Option as our SSA `Id` does not allow dummy values. @@ -368,9 +369,6 @@ impl<'f> LoopInvariantContext<'f> { fn set_induction_var_bounds(&mut self, loop_: &Loop, current_loop: bool) { let bounds = loop_.get_const_bounds(self.inserter.function, self.pre_header()); if let Some((lower_bound, upper_bound)) = bounds { - let bit_size = NumericType::length_type().bit_size(); - let lower_bound = convert_signed_integer_to_field_element(lower_bound, bit_size); - let upper_bound = convert_signed_integer_to_field_element(upper_bound, bit_size); let induction_variable = loop_.get_induction_variable(self.inserter.function); let induction_variable = self.inserter.resolve(induction_variable); if current_loop { @@ -399,7 +397,7 @@ impl<'f> LoopInvariantContext<'f> { let array_typ = self.inserter.function.dfg.type_of_value(*array); let upper_bound = self.outer_induction_variables.get(index).map(|bounds| bounds.1); if let (Type::Array(_, len), Some(upper_bound)) = (array_typ, upper_bound) { - upper_bound.to_u128() <= len.into() + upper_bound.apply(|i| i <= len.into(), |i| i <= len.into()) } else { false } @@ -411,7 +409,9 @@ impl<'f> LoopInvariantContext<'f> { // If the instruction were to be hoisted out of a loop that never executes it could potentially cause the program to fail when it is not meant to fail. let bounds = self.current_induction_variables.values().next().copied(); let does_loop_body_execute = bounds - .map(|(lower_bound, upper_bound)| !(upper_bound - lower_bound).is_zero()) + .and_then(|(lower_bound, upper_bound)| { + upper_bound.reduce(lower_bound, |u, l| u > l, |u, l| u > l) + }) .unwrap_or(false); // If we know the loop will be executed these instructions can still only be hoisted if the instructions // are in a non control dependent block. @@ -576,13 +576,13 @@ impl<'f> LoopInvariantContext<'f> { _ => None, }?; - let min_iter = self.inserter.function.dfg.make_constant(*lower, NumericType::length_type()); - assert!(*upper != FieldElement::zero(), "executing a non executable loop"); - let max_iter = self - .inserter - .function - .dfg - .make_constant(*upper - FieldElement::one(), NumericType::length_type()); + assert!(!upper.is_zero(), "executing a non executable loop"); + + let (upper_field, upper_type) = upper.dec().into_numeric_constant(); + let (lower_field, lower_type) = lower.into_numeric_constant(); + + let min_iter = self.inserter.function.dfg.make_constant(lower_field, lower_type); + let max_iter = self.inserter.function.dfg.make_constant(upper_field, upper_type); if (is_left && self.is_loop_invariant(rhs)) || (!is_left && self.is_loop_invariant(lhs)) { return Some((is_left, min_iter, max_iter)); } @@ -636,9 +636,9 @@ impl<'f> LoopInvariantContext<'f> { lhs: &ValueId, rhs: &ValueId, only_outer_induction: bool, - ) -> Option<(bool, FieldElement, FieldElement, FieldElement)> { - let lhs_const = self.inserter.function.dfg.get_numeric_constant_with_type(*lhs); - let rhs_const = self.inserter.function.dfg.get_numeric_constant_with_type(*rhs); + ) -> Option<(bool, IntegerConstant, IntegerConstant, IntegerConstant)> { + let lhs_const = self.inserter.function.dfg.get_integer_constant(*lhs); + let rhs_const = self.inserter.function.dfg.get_integer_constant(*rhs); match ( lhs_const, rhs_const, @@ -651,10 +651,10 @@ impl<'f> LoopInvariantContext<'f> { .and_then(|v| if only_outer_induction { None } else { Some(v) }) .or(self.outer_induction_variables.get(rhs)), ) { - (Some((lhs, _)), None, None, Some((lower_bound, upper_bound))) => { + (Some(lhs), None, None, Some((lower_bound, upper_bound))) => { Some((false, lhs, *lower_bound, *upper_bound)) } - (None, Some((rhs, _)), Some((lower_bound, upper_bound)), None) => { + (None, Some(rhs), Some((lower_bound, upper_bound)), None) => { Some((true, rhs, *lower_bound, *upper_bound)) } _ => None, @@ -707,6 +707,8 @@ impl<'f> LoopInvariantContext<'f> { // of its inputs to check whether it will ever overflow. // If so, this will cause `eval_constant_binary_op` to return `None`. // Therefore a `Some` value shows that this operation is safe. + let lhs = lhs.into_numeric_constant().0; + let rhs = rhs.into_numeric_constant().0; if eval_constant_binary_op(lhs, rhs, binary.operator, operand_type).is_some() { // Unchecked version of the binary operation let unchecked = Instruction::Binary(Binary { @@ -733,7 +735,7 @@ impl<'f> LoopInvariantContext<'f> { true if upper_bound <= value => SimplifyResult::SimplifiedTo(self.true_value), true if lower_bound >= value => SimplifyResult::SimplifiedTo(self.false_value), false if lower_bound > value => SimplifyResult::SimplifiedTo(self.true_value), - false if upper_bound <= value + FieldElement::one() => { + false if upper_bound <= value.inc() => { SimplifyResult::SimplifiedTo(self.false_value) } _ => SimplifyResult::None, @@ -760,10 +762,10 @@ impl<'f> LoopInvariantContext<'f> { return false; }; if left { - if value != FieldElement::zero() { + if !value.is_zero() { return true; } - } else if lower != FieldElement::zero() { + } else if !lower.is_zero() { return true; } diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs index 0abf85510cb..4d677848217 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs @@ -34,12 +34,9 @@ use crate::{ dom::DominatorTree, function::Function, function_inserter::{ArrayCache, FunctionInserter}, - instruction::{ - Binary, BinaryOp, Instruction, InstructionId, TerminatorInstruction, - binary::try_convert_field_element_to_signed_integer, - }, + instruction::{Binary, BinaryOp, Instruction, InstructionId, TerminatorInstruction}, + integer::IntegerConstant, post_order::PostOrder, - types::NumericType, value::ValueId, }, ssa_gen::Ssa, @@ -286,17 +283,6 @@ impl Loop { Self { header, back_edge_start, blocks } } - /// Handle negative values represented as fields. - fn get_const_as_i128(function: &Function, id: ValueId) -> Option { - let (value, typ) = function.dfg.get_numeric_constant_with_type(id)?; - if matches!(typ, NumericType::NativeField) { - // Shouldn't happen, as fields don't have meaningful ordering. - value.try_into_i128() - } else { - try_convert_field_element_to_signed_integer(value, typ.bit_size()) - } - } - /// Find the lower bound of the loop in the pre-header and return it /// if it's a numeric constant, which it will be if the previous SSA /// steps managed to inline it. @@ -311,9 +297,13 @@ impl Loop { /// v5 = lt v1, u32 4 /// jmpif v5 then: b3, else: b2 /// ``` - fn get_const_lower_bound(&self, function: &Function, pre_header: BasicBlockId) -> Option { + fn get_const_lower_bound( + &self, + function: &Function, + pre_header: BasicBlockId, + ) -> Option { let jump_value = get_induction_variable(function, pre_header).ok()?; - Self::get_const_as_i128(function, jump_value) + function.dfg.get_integer_constant(jump_value) } /// Find the upper bound of the loop in the loop header and return it @@ -330,7 +320,7 @@ impl Loop { /// v5 = lt v1, u32 4 // Upper bound /// jmpif v5 then: b3, else: b2 /// ``` - fn get_const_upper_bound(&self, function: &Function) -> Option { + fn get_const_upper_bound(&self, function: &Function) -> Option { let block = &function.dfg[self.header]; let instructions = block.instructions(); if instructions.is_empty() { @@ -347,14 +337,14 @@ impl Loop { match &function.dfg[instructions[0]] { Instruction::Binary(Binary { lhs: _, operator: BinaryOp::Lt, rhs }) => { - Self::get_const_as_i128(function, *rhs) + function.dfg.get_integer_constant(*rhs) } Instruction::Binary(Binary { lhs: _, operator: BinaryOp::Eq, rhs }) => { // `for i in 0..1` is turned into: // b1(v0: u32): // v12 = eq v0, u32 0 // jmpif v12 then: b3, else: b2 - Self::get_const_as_i128(function, *rhs).map(|c| c + 1) + function.dfg.get_integer_constant(*rhs).map(|c| c.inc()) } other => panic!("Unexpected instruction in header: {other:?}"), } @@ -365,7 +355,7 @@ impl Loop { &self, function: &Function, pre_header: BasicBlockId, - ) -> Option<(i128, i128)> { + ) -> Option<(IntegerConstant, IntegerConstant)> { let lower = self.get_const_lower_bound(function, pre_header)?; let upper = self.get_const_upper_bound(function)?; Some((lower, upper)) @@ -697,13 +687,16 @@ impl Loop { let increments = self.count_induction_increments(function); let all_instructions = self.count_all_instructions(function); - Some(BoilerplateStats { - iterations: (upper - lower).max(0) as usize, - loads, - stores, - increments, - all_instructions, - }) + // Currently we don't iterate in reverse, so if upper <= lower it means 0 iterations. + let iterations: usize = upper + .reduce( + lower, + |u, l| u.saturating_sub(l).max(0) as usize, + |u, l| u.saturating_sub(l) as usize, + ) + .unwrap_or_default(); + + Some(BoilerplateStats { iterations, loads, stores, increments, all_instructions }) } } @@ -1044,6 +1037,7 @@ mod tests { use crate::assert_ssa_snapshot; use crate::errors::RuntimeError; + use crate::ssa::ir::integer::IntegerConstant; use crate::ssa::{Ssa, ir::value::ValueId, opt::assert_normalized_ssa_equals}; use super::{BoilerplateStats, Loops, is_new_size_ok}; @@ -1170,8 +1164,8 @@ mod tests { let (lower, upper) = loop_.get_const_bounds(function, pre_header).expect("bounds are numeric const"); - assert_eq!(lower, 0); - assert_eq!(upper, 4); + assert_eq!(lower, IntegerConstant::Unsigned { value: 0, bit_size: 32 }); + assert_eq!(upper, IntegerConstant::Unsigned { value: 4, bit_size: 32 }); } #[test] diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs index 5dd52eff7ae..9a10f4e1b5c 100644 --- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs @@ -534,10 +534,11 @@ impl FunctionContext<'_> { self.builder.set_location(for_expr.end_range_location); let end_index = self.codegen_non_tuple_expression(&for_expr.end_range)?; - if let (Some(start_constant), Some(end_constant)) = ( - self.builder.current_function.dfg.get_numeric_constant(start_index), - self.builder.current_function.dfg.get_numeric_constant(end_index), - ) { + let range_bound = |id| self.builder.current_function.dfg.get_integer_constant(id); + + if let (Some(start_constant), Some(end_constant)) = + (range_bound(start_index), range_bound(end_index)) + { // If we can determine that the loop contains zero iterations then there's no need to codegen the loop. if start_constant >= end_constant { return Ok(Self::unit_value()); diff --git a/test_programs/execution_success/regression_8011/Nargo.toml b/test_programs/execution_success/regression_8011/Nargo.toml new file mode 100644 index 00000000000..815e4a279bc --- /dev/null +++ b/test_programs/execution_success/regression_8011/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "regression_8011" +type = "bin" +authors = [""] + +[dependencies] diff --git a/test_programs/execution_success/regression_8011/Prover.toml b/test_programs/execution_success/regression_8011/Prover.toml new file mode 100644 index 00000000000..23badac2fd8 --- /dev/null +++ b/test_programs/execution_success/regression_8011/Prover.toml @@ -0,0 +1 @@ +return = 15 diff --git a/test_programs/execution_success/regression_8011/src/main.nr b/test_programs/execution_success/regression_8011/src/main.nr new file mode 100644 index 00000000000..e683b84ecd1 --- /dev/null +++ b/test_programs/execution_success/regression_8011/src/main.nr @@ -0,0 +1,26 @@ +unconstrained fn main() -> pub u32 { + let s1 = loop_with_negative_literal(); + let s2 = loop_with_u128_literal(); + assert_eq(s1, s2); + s1 +} + +fn loop_with_negative_literal() -> u32 { + let s: i64 = -5; + let e: i64 = 10; + let mut sum = 0; + for _ in s..e { + sum += 1; + } + sum +} + +fn loop_with_u128_literal() -> u32 { + let s: u128 = 170141183460469231731687303715884105715; + let e: u128 = 170141183460469231731687303715884105730; + let mut sum = 0; + for _ in s..e { + sum += 1; + } + sum +} diff --git a/test_programs/execution_success/regression_8011/stdout.txt b/test_programs/execution_success/regression_8011/stdout.txt new file mode 100644 index 00000000000..9bbe0c91cde --- /dev/null +++ b/test_programs/execution_success/regression_8011/stdout.txt @@ -0,0 +1 @@ +[regression_8011] Circuit output: Field(15) diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 5347f495849..8ebfeb1d652 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -46,10 +46,10 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", - "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNq+yrJI1SiF0kqtC4v47qaiIKWX/yJE5ifiVwpzN8e0v5133XAar6b5uZt+PLRzNw75dH8UZj91fd+dd99fG7t8uOo1f720w3K8zu00myb6wqThaJpKcn3q+mSaYB+/hXE1my8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3Dpyt1kWFi5oWweLC4aLEheDC4yLgQnGBzQM2D9hcsblic8Xmis0Vmys2V2yu2FyxuWLziM0jNo/YPGLziM3jtnlZfwqx60JxEXFR0aLa/q9C+SlCWBceFwEXiovtZ1f1U0S/KmpH76hLfIfgwuMi4EJxEVnxyKe/durafZ/eK+PpNhy+Nsj5/5JWy+RlGg/peJvSslZ+bZTLO8ZZWzgb8k9x7nXUfKzyPfmuJw==", "file_map": { "50": { - "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start..end {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_0.snap index 5347f495849..8ebfeb1d652 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_0.snap @@ -46,10 +46,10 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", - "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNq+yrJI1SiF0kqtC4v47qaiIKWX/yJE5ifiVwpzN8e0v5133XAar6b5uZt+PLRzNw75dH8UZj91fd+dd99fG7t8uOo1f720w3K8zu00myb6wqThaJpKcn3q+mSaYB+/hXE1my8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3Dpyt1kWFi5oWweLC4aLEheDC4yLgQnGBzQM2D9hcsblic8Xmis0Vmys2V2yu2FyxuWLziM0jNo/YPGLziM3jtnlZfwqx60JxEXFR0aLa/q9C+SlCWBceFwEXiovtZ1f1U0S/KmpH76hLfIfgwuMi4EJxEVnxyKe/durafZ/eK+PpNhy+Nsj5/5JWy+RlGg/peJvSslZ+bZTLO8ZZWzgb8k9x7nXUfKzyPfmuJw==", "file_map": { "50": { - "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start..end {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 5347f495849..8ebfeb1d652 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -46,10 +46,10 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", - "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNq+yrJI1SiF0kqtC4v47qaiIKWX/yJE5ifiVwpzN8e0v5133XAar6b5uZt+PLRzNw75dH8UZj91fd+dd99fG7t8uOo1f720w3K8zu00myb6wqThaJpKcn3q+mSaYB+/hXE1my8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3Dpyt1kWFi5oWweLC4aLEheDC4yLgQnGBzQM2D9hcsblic8Xmis0Vmys2V2yu2FyxuWLziM0jNo/YPGLziM3jtnlZfwqx60JxEXFR0aLa/q9C+SlCWBceFwEXiovtZ1f1U0S/KmpH76hLfIfgwuMi4EJxEVnxyKe/durafZ/eK+PpNhy+Nsj5/5JWy+RlGg/peJvSslZ+bZTLO8ZZWzgb8k9x7nXUfKzyPfmuJw==", "file_map": { "50": { - "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start..end {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 5347f495849..8ebfeb1d652 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -46,10 +46,10 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", - "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNq+yrJI1SiF0kqtC4v47qaiIKWX/yJE5ifiVwpzN8e0v5133XAar6b5uZt+PLRzNw75dH8UZj91fd+dd99fG7t8uOo1f720w3K8zu00myb6wqThaJpKcn3q+mSaYB+/hXE1my8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3Dpyt1kWFi5oWweLC4aLEheDC4yLgQnGBzQM2D9hcsblic8Xmis0Vmys2V2yu2FyxuWLziM0jNo/YPGLziM3jtnlZfwqx60JxEXFR0aLa/q9C+SlCWBceFwEXiovtZ1f1U0S/KmpH76hLfIfgwuMi4EJxEVnxyKe/durafZ/eK+PpNhy+Nsj5/5JWy+RlGg/peJvSslZ+bZTLO8ZZWzgb8k9x7nXUfKzyPfmuJw==", "file_map": { "50": { - "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start..end {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_0.snap index 5347f495849..8ebfeb1d652 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_0.snap @@ -46,10 +46,10 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", - "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNq+yrJI1SiF0kqtC4v47qaiIKWX/yJE5ifiVwpzN8e0v5133XAar6b5uZt+PLRzNw75dH8UZj91fd+dd99fG7t8uOo1f720w3K8zu00myb6wqThaJpKcn3q+mSaYB+/hXE1my8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3Dpyt1kWFi5oWweLC4aLEheDC4yLgQnGBzQM2D9hcsblic8Xmis0Vmys2V2yu2FyxuWLziM0jNo/YPGLziM3jtnlZfwqx60JxEXFR0aLa/q9C+SlCWBceFwEXiovtZ1f1U0S/KmpH76hLfIfgwuMi4EJxEVnxyKe/durafZ/eK+PpNhy+Nsj5/5JWy+RlGg/peJvSslZ+bZTLO8ZZWzgb8k9x7nXUfKzyPfmuJw==", "file_map": { "50": { - "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start..end {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 5347f495849..8ebfeb1d652 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8009/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -46,10 +46,10 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1YTU/bQBDdtTd2nDQNbU9V1VNV9VBVsotdh1NbtYA4c0JcsAiRQOI/5KcTw4z8MoyNgHVAiJWsXXuf37z58NiJNTcjWB2W1g6uycGYPzSnjxuZR660T53Wo04LOoNbCxCPa23/kuZEYOr90KPzibDrk3+W5mVi1odn/dsJcPbA/5P5XT/8aUw8/5fr/EbYDQVO3uMAswuYXYGZ0BrrkHl4D+uR7x+uji3TrN+Z5p567IEd5k4En+fa+tVz7rMPLfrrMaY4zIWvWCfOn5aC+See+MvF+uC8DYlvQPzSpszt2378TdnWVPBLmxb0ov6PNEer4xOtub6x500B97kDZxXcpnIyMt05cc8sJw70ov4vEMOvItZjo+fkWwfOKTjWGNF5CBoxn2OBfwMx5OtDWI+ET4z/Dhp+AIfPumjLQyT4pc1I+MjvmgDwkgPxA4UfvxPinvx9aG8KhJ6nfg4C0Iv6C5rr2Je0vqs37XTgAgX32pvu15t+Qwz/ili39aZ/HTin4Dbdm/ZBwwFwvITeZBV+/E5jPu2b1rbM9QiVa7Kv9PVbYEvxw23Gdpa0xNwX/wQ0Mz+/X2qbh8LPxJOOmTiX9WZMUz+oTX77DRW87cCzb9gXY8DguwzxxxCTI1pPFXtcI2PYHyj7mr+h0d/vmr9RCz4W+hl/QnN9fkFrra5jYW8A+rR8cF3ep46uuZYNztfzUs6aP3rCZROH0NweDvYRf07nI/CD58fU+6KsssV2taiKaj7PT6v3gr8eWDu+7edFVZ5WZZbt5NlZnhV32b8C59X6eaUUAAA=", - "debug_symbols": "ldfBisIwEIDhd8m5h6STTNK+yrJI1SqF0kqtC4v47qaiIKWX/yJE5ifiJ5a5m2O7v5133XAar6b+uZt+PDRzNw75dH8UZj91fd+dd99vG7u8uPSav16aYTle52aaTR19YdrhaOokuT51fWvqYB+/hXEVmy8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3DpxN6yLhoqJFsLhwuChxIbjwuAi4UFxg84DNAzZXbK7YXLG5YnPF5orNFZsrNldsrtg8YvOIzSM2j9g8YvO4bV5Wn0LsulBcRFwkWqTt7yp8HjguxHXhcRFwobjY/u1q+hRRV0Xl6B1Vie8QXHhcBFwoLiIrHvn010xds+/b98p4ug2Hrw1y/r+0q2XyMo2H9nib2mWt/Nool/8YZ23hbMgfxbnXUfMx5XvyXU8=", + "debug_symbols": "ldfBisIwEIDhd8m5h6STTNq+yrJI1SiF0kqtC4v47qaiIKWX/yJE5ifiVwpzN8e0v5133XAar6b5uZt+PLRzNw75dH8UZj91fd+dd99fG7t8uOo1f720w3K8zu00myb6wqThaJpKcn3q+mSaYB+/hXE1my8tnHdwvoTzAuc9nA9wXuF8hPPQt4S+An0F+gr0Fegr0Fegr0Bfgb4CfQX6eujroa+Hvh76eujroa+Hvn7T11n3Dpyt1kWFi5oWweLC4aLEheDC4yLgQnGBzQM2D9hcsblic8Xmis0Vmys2V2yu2FyxuWLziM0jNo/YPGLziM3jtnlZfwqx60JxEXFR0aLa/q9C+SlCWBceFwEXiovtZ1f1U0S/KmpH76hLfIfgwuMi4EJxEVnxyKe/durafZ/eK+PpNhy+Nsj5/5JWy+RlGg/peJvSslZ+bZTLO8ZZWzgb8k9x7nXUfKzyPfmuJw==", "file_map": { "50": { - "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start .. end {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main(start: i64, end: i64) -> pub u32 {\n let start = (start % 5);\n let end = (end % 5);\n let mut sum = 0;\n for i in start..end {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..d7aa5c2c874 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -0,0 +1,43 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/9VWzU6DQBBeykKLtWmjL6AXve4KFDyYYKwXE+PFg4mntZXn4NGFZDZMxwFaAaNfQnaWnX7zszNDHVHDgVWKfTjiADgt795hDWCdoHO3fDLYq37QAbE7JH+qonXAxDeg/2EAnM44/Mryj5R/NQWex6Lmx7FYu7PyOUXyEuRFy+/H9L282zhAnEPzl9DnDf7b2Co8FKPYVpZ/Mw6/nsM9Xv7CXZUIFyR/GNwcchkdXIvXIC8YPYHOaD1LEu9ItRMtiL0mH9vidVG89ygm0REvvkMPyZhTgtzU7x7Rv4DV5k0SPzPYq544Q7yC2JqLuu9kMbz9JFXK2nWLOg9czUp0jvWvYH/SEEf2Qz/zxOg8NLmJzW4XbQ3NU4UJyhPubVoX1C/K47ZwrxguOwO5nuoV8z4+uNrrw09gLL83Dr/m5pHNlV/xi/08zgbyIyV764MvakjGN2y/eqaMvmzRt7F5SN9HOlN0jvVTlJM1yEvRPKvm6Nxlzrl4XfH9e7Qp+Hh9Rh/zeUT/DtYqH28grxiffOIf9oW7D1uXh9bRX5kBld8Z7LtqNclbEXIz4Bj+tP34hpsBx/B3oHMGPKH3tIc80fx/hvbQC+J8Bvk/9dArrH16iMvXoT1k72Ho73gUm2RrEq1vI/0Z6bjrO/4FDs9oNO0PAAA=", + "debug_symbols": "ldbbioUgFAbgd/G6C11q6n6VYdh0sE0QFR0GhujdR4fdJsSb/yYw/o8FK7V1sNbX++vZj920ssfXwYapqbZ+GsPqOAtWL/0w9K/n/TXj8SHK//w6V2Ncrlu1bOyhecH82LKHsUF3/eDju/O7YMKAeQvmHZYnDuYFmKdc3sl3XgiTAokChQKNghIFBgXZryzkR0iXCocKyWEhUKGyNUhfgrRKhYAFwSLbXTJ0CSNT4VChOSwELLI7nay6hKNUlHANA9ewsHCoKDksBCwIFtnuqo9QVqfCwMKiwqj8DX2dD83T82Hy/yShL0HpLjEOrWE5WsMKWBAsJCwULDQmzrD6qZa+qgf/Hj+6fWxu08j2O/tkMJmXqfHtvvg4otymk9j1cF9LG0eD2FBrC8dDjVDnDw==", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_0.snap new file mode 100644 index 00000000000..f9a2396ef70 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_0.snap @@ -0,0 +1,43 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/7VWzU7DMAx21nZrGdMQXDhxReJCw1pauDAJDiDxEmGjz7FHpwVb9Uya/SWWqiTN18/2Fyepgt4UtjFsm4I9TDnefWKbYTti81H7LHGcn2Y6E3598td5UWaW/DzGv8iQU4Xhz4k/kP75BHneNj0/z4X8pu1zzvoz7M8c34eMvV3bImOcvvlb01cD8Xc2RR1emQ4cC7CtI29BxEw2EroFyiu/cORFvmM2F5/gu9m2L+JPPPELM8Q/DqOdJv5JmPg11ZES/IA5XYt1OvMURy3GFEMKvcWW2Lh/Bf19wfGJA0+5JQyfMkzG5jn+mWlyg/05/K9dqnGf+3Of/cO/72Jf4njXOlSN0xa2/XMIf+2efrDV9yH8O8xa36RVt5a37D2fS6CvASViAzZHeM0477A/h+H7TYlxjFyynpTwR/h7bEOf3ZeMF4Qv19kxZflHjvz5fo8s+LHA0/4cD+BToRfhH7Ht5j+wb9tXqfAXsfhs9TBxaGGrM9eZ4dKE4/fRJLbkJDV5wfZQTfjPv+2MdmkydLf8cm16nK8aruq/u6WzaNPrwNcVhP9E4N9xzO8Sns/yyDibyuhmYRpTmvW6WBm51zqjdZgG8F+UplqZSuunQn8Xutzl/wdvYFtnCQ4AAA==", + "debug_symbols": "tdbbaoQwEAbgd8m1FzlNovsqpSwe4hIQFQ+FIr57TVkXSZeCyH8jJMx8gUlMZmGVK+bH3bd1N7Lbx8Karswn37XbaFkTVgy+afzjfpxmPHyE/o0f+7wNw3HKh4ndiCfMtRW72XTLrn3jwtya/AmUpJ6RkvQx9DNhgnC0wdEWRsuLtbZyp62KacLRBkdbGK34NTrVO53JmBbv6GzfdyHs/7Z+2Tql2JZAWwHt7JpNfA8lHv82+mJNSNBuy/iY6Lc1EeqFqyzO0Kcz6HSGOZ0BrD9xXP1JAG3guSEFtDXQJqCdwm5zymC3ucE9FEbgaImjFY7WIHrdRl/54POicc+Wt57b8tABT9+9i5rhfuhKV82DC23xoSMOB8LYxMrQDYYttCqxtK2xrfMD", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..f9a2396ef70 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -0,0 +1,43 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/7VWzU7DMAx21nZrGdMQXDhxReJCw1pauDAJDiDxEmGjz7FHpwVb9Uya/SWWqiTN18/2Fyepgt4UtjFsm4I9TDnefWKbYTti81H7LHGcn2Y6E3598td5UWaW/DzGv8iQU4Xhz4k/kP75BHneNj0/z4X8pu1zzvoz7M8c34eMvV3bImOcvvlb01cD8Xc2RR1emQ4cC7CtI29BxEw2EroFyiu/cORFvmM2F5/gu9m2L+JPPPELM8Q/DqOdJv5JmPg11ZES/IA5XYt1OvMURy3GFEMKvcWW2Lh/Bf19wfGJA0+5JQyfMkzG5jn+mWlyg/05/K9dqnGf+3Of/cO/72Jf4njXOlSN0xa2/XMIf+2efrDV9yH8O8xa36RVt5a37D2fS6CvASViAzZHeM0477A/h+H7TYlxjFyynpTwR/h7bEOf3ZeMF4Qv19kxZflHjvz5fo8s+LHA0/4cD+BToRfhH7Ht5j+wb9tXqfAXsfhs9TBxaGGrM9eZ4dKE4/fRJLbkJDV5wfZQTfjPv+2MdmkydLf8cm16nK8aruq/u6WzaNPrwNcVhP9E4N9xzO8Sns/yyDibyuhmYRpTmvW6WBm51zqjdZgG8F+UplqZSuunQn8Xutzl/wdvYFtnCQ4AAA==", + "debug_symbols": "tdbbaoQwEAbgd8m1FzlNovsqpSwe4hIQFQ+FIr57TVkXSZeCyH8jJMx8gUlMZmGVK+bH3bd1N7Lbx8Karswn37XbaFkTVgy+afzjfpxmPHyE/o0f+7wNw3HKh4ndiCfMtRW72XTLrn3jwtya/AmUpJ6RkvQx9DNhgnC0wdEWRsuLtbZyp62KacLRBkdbGK34NTrVO53JmBbv6GzfdyHs/7Z+2Tql2JZAWwHt7JpNfA8lHv82+mJNSNBuy/iY6Lc1EeqFqyzO0Kcz6HSGOZ0BrD9xXP1JAG3guSEFtDXQJqCdwm5zymC3ucE9FEbgaImjFY7WIHrdRl/54POicc+Wt57b8tABT9+9i5rhfuhKV82DC23xoSMOB8LYxMrQDYYttCqxtK2xrfMD", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..d7aa5c2c874 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -0,0 +1,43 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/9VWzU6DQBBeykKLtWmjL6AXve4KFDyYYKwXE+PFg4mntZXn4NGFZDZMxwFaAaNfQnaWnX7zszNDHVHDgVWKfTjiADgt795hDWCdoHO3fDLYq37QAbE7JH+qonXAxDeg/2EAnM44/Mryj5R/NQWex6Lmx7FYu7PyOUXyEuRFy+/H9L282zhAnEPzl9DnDf7b2Co8FKPYVpZ/Mw6/nsM9Xv7CXZUIFyR/GNwcchkdXIvXIC8YPYHOaD1LEu9ItRMtiL0mH9vidVG89ygm0REvvkMPyZhTgtzU7x7Rv4DV5k0SPzPYq544Q7yC2JqLuu9kMbz9JFXK2nWLOg9czUp0jvWvYH/SEEf2Qz/zxOg8NLmJzW4XbQ3NU4UJyhPubVoX1C/K47ZwrxguOwO5nuoV8z4+uNrrw09gLL83Dr/m5pHNlV/xi/08zgbyIyV764MvakjGN2y/eqaMvmzRt7F5SN9HOlN0jvVTlJM1yEvRPKvm6Nxlzrl4XfH9e7Qp+Hh9Rh/zeUT/DtYqH28grxiffOIf9oW7D1uXh9bRX5kBld8Z7LtqNclbEXIz4Bj+tP34hpsBx/B3oHMGPKH3tIc80fx/hvbQC+J8Bvk/9dArrH16iMvXoT1k72Ho73gUm2RrEq1vI/0Z6bjrO/4FDs9oNO0PAAA=", + "debug_symbols": "ldbbioUgFAbgd/G6C11q6n6VYdh0sE0QFR0GhujdR4fdJsSb/yYw/o8FK7V1sNbX++vZj920ssfXwYapqbZ+GsPqOAtWL/0w9K/n/TXj8SHK//w6V2Ncrlu1bOyhecH82LKHsUF3/eDju/O7YMKAeQvmHZYnDuYFmKdc3sl3XgiTAokChQKNghIFBgXZryzkR0iXCocKyWEhUKGyNUhfgrRKhYAFwSLbXTJ0CSNT4VChOSwELLI7nay6hKNUlHANA9ewsHCoKDksBCwIFtnuqo9QVqfCwMKiwqj8DX2dD83T82Hy/yShL0HpLjEOrWE5WsMKWBAsJCwULDQmzrD6qZa+qgf/Hj+6fWxu08j2O/tkMJmXqfHtvvg4otymk9j1cF9LG0eD2FBrC8dDjVDnDw==", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_0.snap new file mode 100644 index 00000000000..f9a2396ef70 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_0.snap @@ -0,0 +1,43 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/7VWzU7DMAx21nZrGdMQXDhxReJCw1pauDAJDiDxEmGjz7FHpwVb9Uya/SWWqiTN18/2Fyepgt4UtjFsm4I9TDnefWKbYTti81H7LHGcn2Y6E3598td5UWaW/DzGv8iQU4Xhz4k/kP75BHneNj0/z4X8pu1zzvoz7M8c34eMvV3bImOcvvlb01cD8Xc2RR1emQ4cC7CtI29BxEw2EroFyiu/cORFvmM2F5/gu9m2L+JPPPELM8Q/DqOdJv5JmPg11ZES/IA5XYt1OvMURy3GFEMKvcWW2Lh/Bf19wfGJA0+5JQyfMkzG5jn+mWlyg/05/K9dqnGf+3Of/cO/72Jf4njXOlSN0xa2/XMIf+2efrDV9yH8O8xa36RVt5a37D2fS6CvASViAzZHeM0477A/h+H7TYlxjFyynpTwR/h7bEOf3ZeMF4Qv19kxZflHjvz5fo8s+LHA0/4cD+BToRfhH7Ht5j+wb9tXqfAXsfhs9TBxaGGrM9eZ4dKE4/fRJLbkJDV5wfZQTfjPv+2MdmkydLf8cm16nK8aruq/u6WzaNPrwNcVhP9E4N9xzO8Sns/yyDibyuhmYRpTmvW6WBm51zqjdZgG8F+UplqZSuunQn8Xutzl/wdvYFtnCQ4AAA==", + "debug_symbols": "tdbbaoQwEAbgd8m1FzlNovsqpSwe4hIQFQ+FIr57TVkXSZeCyH8jJMx8gUlMZmGVK+bH3bd1N7Lbx8Karswn37XbaFkTVgy+afzjfpxmPHyE/o0f+7wNw3HKh4ndiCfMtRW72XTLrn3jwtya/AmUpJ6RkvQx9DNhgnC0wdEWRsuLtbZyp62KacLRBkdbGK34NTrVO53JmBbv6GzfdyHs/7Z+2Tql2JZAWwHt7JpNfA8lHv82+mJNSNBuy/iY6Lc1EeqFqyzO0Kcz6HSGOZ0BrD9xXP1JAG3guSEFtDXQJqCdwm5zymC3ucE9FEbgaImjFY7WIHrdRl/54POicc+Wt57b8tABT9+9i5rhfuhKV82DC23xoSMOB8LYxMrQDYYttCqxtK2xrfMD", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..f9a2396ef70 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -0,0 +1,43 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": { + "abi_type": { + "kind": "integer", + "sign": "unsigned", + "width": 32 + }, + "visibility": "public" + }, + "error_types": { + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/7VWzU7DMAx21nZrGdMQXDhxReJCw1pauDAJDiDxEmGjz7FHpwVb9Uya/SWWqiTN18/2Fyepgt4UtjFsm4I9TDnefWKbYTti81H7LHGcn2Y6E3598td5UWaW/DzGv8iQU4Xhz4k/kP75BHneNj0/z4X8pu1zzvoz7M8c34eMvV3bImOcvvlb01cD8Xc2RR1emQ4cC7CtI29BxEw2EroFyiu/cORFvmM2F5/gu9m2L+JPPPELM8Q/DqOdJv5JmPg11ZES/IA5XYt1OvMURy3GFEMKvcWW2Lh/Bf19wfGJA0+5JQyfMkzG5jn+mWlyg/05/K9dqnGf+3Of/cO/72Jf4njXOlSN0xa2/XMIf+2efrDV9yH8O8xa36RVt5a37D2fS6CvASViAzZHeM0477A/h+H7TYlxjFyynpTwR/h7bEOf3ZeMF4Qv19kxZflHjvz5fo8s+LHA0/4cD+BToRfhH7Ht5j+wb9tXqfAXsfhs9TBxaGGrM9eZ4dKE4/fRJLbkJDV5wfZQTfjPv+2MdmkydLf8cm16nK8aruq/u6WzaNPrwNcVhP9E4N9xzO8Sns/yyDibyuhmYRpTmvW6WBm51zqjdZgG8F+UplqZSuunQn8Xutzl/wdvYFtnCQ4AAA==", + "debug_symbols": "tdbbaoQwEAbgd8m1FzlNovsqpSwe4hIQFQ+FIr57TVkXSZeCyH8jJMx8gUlMZmGVK+bH3bd1N7Lbx8Karswn37XbaFkTVgy+afzjfpxmPHyE/o0f+7wNw3HKh4ndiCfMtRW72XTLrn3jwtya/AmUpJ6RkvQx9DNhgnC0wdEWRsuLtbZyp62KacLRBkdbGK34NTrVO53JmBbv6GzfdyHs/7Z+2Tql2JZAWwHt7JpNfA8lHv82+mJNSNBuy/iY6Lc1EeqFqyzO0Kcz6HSGOZ0BrD9xXP1JAG3guSEFtDXQJqCdwm5zymC3ucE9FEbgaImjFY7WIHrdRl/54POicc+Wt57b8tABT9+9i5rhfuhKV82DC23xoSMOB8LYxMrQDYYttCqxtK2xrfMD", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} From e99a58b3ab6d5bafbf562ba789a90262e5b2aa4f Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 13:33:44 +0100 Subject: [PATCH 11/21] Change magic numbers into formula --- compiler/noirc_evaluator/src/ssa/opt/unrolling.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs index 166481b1112..200c8a759d5 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs @@ -1220,7 +1220,8 @@ mod tests { #[test] fn test_boilerplate_stats_i64_empty() { // Looping 0..-1, which should be 0 iterations. - let ssa = brillig_unroll_test_case_6470_with_params("i64", "0", "18446744073709551615"); + // u64::MAX is how -1 is represented as a Field. + let ssa = brillig_unroll_test_case_6470_with_params("i64", "0", &format!("{}", u64::MAX)); let stats = loop0_stats(&ssa); assert_eq!(stats.iterations, 0); assert_eq!(stats.unrolled_instructions(), 0); @@ -1229,10 +1230,11 @@ mod tests { #[test] fn test_boilerplate_stats_i64_non_empty() { // Looping -4..-1, which should be 3 iterations. + // u64::MAX-3 is how -4 is represented as a Field. let ssa = brillig_unroll_test_case_6470_with_params( "i64", - "18446744073709551612", - "18446744073709551615", + &format!("{}", u64::MAX - 3), + &format!("{}", u64::MAX), ); let stats = loop0_stats(&ssa); assert_eq!(stats.iterations, 3); From 6e04f9397b4c5733ab03f8701b8823ff690ee0fb Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 13:53:05 +0100 Subject: [PATCH 12/21] Fix insta --- ...tests__force_brillig_false_inliner_-9223372036854775808.snap | 2 +- .../execute__tests__force_brillig_false_inliner_0.snap | 2 +- ..._tests__force_brillig_false_inliner_9223372036854775807.snap | 2 +- ..._tests__force_brillig_true_inliner_-9223372036854775808.snap | 2 +- .../execute__tests__force_brillig_true_inliner_0.snap | 2 +- ...__tests__force_brillig_true_inliner_9223372036854775807.snap | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index d7aa5c2c874..784addfac26 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -30,7 +30,7 @@ expression: artifact "debug_symbols": "ldbbioUgFAbgd/G6C11q6n6VYdh0sE0QFR0GhujdR4fdJsSb/yYw/o8FK7V1sNbX++vZj920ssfXwYapqbZ+GsPqOAtWL/0w9K/n/TXj8SHK//w6V2Ncrlu1bOyhecH82LKHsUF3/eDju/O7YMKAeQvmHZYnDuYFmKdc3sl3XgiTAokChQKNghIFBgXZryzkR0iXCocKyWEhUKGyNUhfgrRKhYAFwSLbXTJ0CSNT4VChOSwELLI7nay6hKNUlHANA9ewsHCoKDksBCwIFtnuqo9QVqfCwMKiwqj8DX2dD83T82Hy/yShL0HpLjEOrWE5WsMKWBAsJCwULDQmzrD6qZa+qgf/Hj+6fWxu08j2O/tkMJmXqfHtvvg4otymk9j1cF9LG0eD2FBrC8dDjVDnDw==", "file_map": { "50": { - "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_0.snap index f9a2396ef70..321ac2661d5 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_0.snap @@ -30,7 +30,7 @@ expression: artifact "debug_symbols": "tdbbaoQwEAbgd8m1FzlNovsqpSwe4hIQFQ+FIr57TVkXSZeCyH8jJMx8gUlMZmGVK+bH3bd1N7Lbx8Karswn37XbaFkTVgy+afzjfpxmPHyE/o0f+7wNw3HKh4ndiCfMtRW72XTLrn3jwtya/AmUpJ6RkvQx9DNhgnC0wdEWRsuLtbZyp62KacLRBkdbGK34NTrVO53JmBbv6GzfdyHs/7Z+2Tql2JZAWwHt7JpNfA8lHv82+mJNSNBuy/iY6Lc1EeqFqyzO0Kcz6HSGOZ0BrD9xXP1JAG3guSEFtDXQJqCdwm5zymC3ucE9FEbgaImjFY7WIHrdRl/54POicc+Wt57b8tABT9+9i5rhfuhKV82DC23xoSMOB8LYxMrQDYYttCqxtK2xrfMD", "file_map": { "50": { - "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index f9a2396ef70..321ac2661d5 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -30,7 +30,7 @@ expression: artifact "debug_symbols": "tdbbaoQwEAbgd8m1FzlNovsqpSwe4hIQFQ+FIr57TVkXSZeCyH8jJMx8gUlMZmGVK+bH3bd1N7Lbx8Karswn37XbaFkTVgy+afzjfpxmPHyE/o0f+7wNw3HKh4ndiCfMtRW72XTLrn3jwtya/AmUpJ6RkvQx9DNhgnC0wdEWRsuLtbZyp62KacLRBkdbGK34NTrVO53JmBbv6GzfdyHs/7Z+2Tql2JZAWwHt7JpNfA8lHv82+mJNSNBuy/iY6Lc1EeqFqyzO0Kcz6HSGOZ0BrD9xXP1JAG3guSEFtDXQJqCdwm5zymC3ucE9FEbgaImjFY7WIHrdRl/54POicc+Wt57b8tABT9+9i5rhfuhKV82DC23xoSMOB8LYxMrQDYYttCqxtK2xrfMD", "file_map": { "50": { - "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index d7aa5c2c874..784addfac26 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -30,7 +30,7 @@ expression: artifact "debug_symbols": "ldbbioUgFAbgd/G6C11q6n6VYdh0sE0QFR0GhujdR4fdJsSb/yYw/o8FK7V1sNbX++vZj920ssfXwYapqbZ+GsPqOAtWL/0w9K/n/TXj8SHK//w6V2Ncrlu1bOyhecH82LKHsUF3/eDju/O7YMKAeQvmHZYnDuYFmKdc3sl3XgiTAokChQKNghIFBgXZryzkR0iXCocKyWEhUKGyNUhfgrRKhYAFwSLbXTJ0CSNT4VChOSwELLI7nay6hKNUlHANA9ewsHCoKDksBCwIFtnuqo9QVqfCwMKiwqj8DX2dD83T82Hy/yShL0HpLjEOrWE5WsMKWBAsJCwULDQmzrD6qZa+qgf/Hj+6fWxu08j2O/tkMJmXqfHtvvg4otymk9j1cF9LG0eD2FBrC8dDjVDnDw==", "file_map": { "50": { - "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_0.snap index f9a2396ef70..321ac2661d5 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_0.snap @@ -30,7 +30,7 @@ expression: artifact "debug_symbols": "tdbbaoQwEAbgd8m1FzlNovsqpSwe4hIQFQ+FIr57TVkXSZeCyH8jJMx8gUlMZmGVK+bH3bd1N7Lbx8Karswn37XbaFkTVgy+afzjfpxmPHyE/o0f+7wNw3HKh4ndiCfMtRW72XTLrn3jwtya/AmUpJ6RkvQx9DNhgnC0wdEWRsuLtbZyp62KacLRBkdbGK34NTrVO53JmBbv6GzfdyHs/7Z+2Tql2JZAWwHt7JpNfA8lHv82+mJNSNBuy/iY6Lc1EeqFqyzO0Kcz6HSGOZ0BrD9xXP1JAG3guSEFtDXQJqCdwm5zymC3ucE9FEbgaImjFY7WIHrdRl/54POicc+Wt57b8tABT9+9i5rhfuhKV82DC23xoSMOB8LYxMrQDYYttCqxtK2xrfMD", "file_map": { "50": { - "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index f9a2396ef70..321ac2661d5 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_8011/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -30,7 +30,7 @@ expression: artifact "debug_symbols": "tdbbaoQwEAbgd8m1FzlNovsqpSwe4hIQFQ+FIr57TVkXSZeCyH8jJMx8gUlMZmGVK+bH3bd1N7Lbx8Karswn37XbaFkTVgy+afzjfpxmPHyE/o0f+7wNw3HKh4ndiCfMtRW72XTLrn3jwtya/AmUpJ6RkvQx9DNhgnC0wdEWRsuLtbZyp62KacLRBkdbGK34NTrVO53JmBbv6GzfdyHs/7Z+2Tql2JZAWwHt7JpNfA8lHv82+mJNSNBuy/iY6Lc1EeqFqyzO0Kcz6HSGOZ0BrD9xXP1JAG3guSEFtDXQJqCdwm5zymC3ucE9FEbgaImjFY7WIHrdRl/54POicc+Wt57b8tABT9+9i5rhfuhKV82DC23xoSMOB8LYxMrQDYYttCqxtK2xrfMD", "file_map": { "50": { - "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}", + "source": "unconstrained fn main() -> pub u32 {\n let s1 = loop_with_negative_literal();\n let s2 = loop_with_u128_literal();\n assert_eq(s1, s2);\n s1\n}\n\nfn loop_with_negative_literal() -> u32 {\n let s: i64 = -5;\n let e: i64 = 10;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n\nfn loop_with_u128_literal() -> u32 {\n let s: u128 = 170141183460469231731687303715884105715;\n let e: u128 = 170141183460469231731687303715884105730;\n let mut sum = 0;\n for _ in s..e {\n sum += 1;\n }\n sum\n}\n", "path": "" } }, From a72c5d71656c11854a661adb6c844a70748b3562 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 14:12:32 +0100 Subject: [PATCH 13/21] Change the test so it's a non-empty range --- tooling/ast_fuzzer/src/program/tests.rs | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/tooling/ast_fuzzer/src/program/tests.rs b/tooling/ast_fuzzer/src/program/tests.rs index 0c85debab07..9f1e93d34e5 100644 --- a/tooling/ast_fuzzer/src/program/tests.rs +++ b/tooling/ast_fuzzer/src/program/tests.rs @@ -58,11 +58,8 @@ fn test_modulo_of_negative_literals_in_range() { let index_type = Type::Integer(noirc_frontend::shared::Signedness::Signed, IntegerBitSize::SixtyFour); - let start_range = range_modulo( - int_literal(51675949543456665u64, true, index_type.clone()), - index_type.clone(), - max_size, - ); + let start_range = + range_modulo(int_literal(4u64, true, index_type.clone()), index_type.clone(), max_size); let end_range = range_modulo(int_literal(1u64, true, index_type.clone()), index_type.clone(), max_size); @@ -83,7 +80,7 @@ fn test_modulo_of_negative_literals_in_range() { assert_ssa_snapshot!(ssa, @r" acir(inline) fn main f0 { b0(): - jmp b1(i64 0) + jmp b1(i64 18446744073709551612) b1(v0: i64): v3 = lt v0, i64 18446744073709551615 jmpif v3 then: b2, else: b3 From 2c5dcf6b4f71a1673fe6c9d75e68b0a7ab95012b Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 14:14:55 +0100 Subject: [PATCH 14/21] Change the lower bound so we see the effect of the modulo --- tooling/ast_fuzzer/src/program/tests.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tooling/ast_fuzzer/src/program/tests.rs b/tooling/ast_fuzzer/src/program/tests.rs index 9f1e93d34e5..d7f1c4dff50 100644 --- a/tooling/ast_fuzzer/src/program/tests.rs +++ b/tooling/ast_fuzzer/src/program/tests.rs @@ -59,7 +59,7 @@ fn test_modulo_of_negative_literals_in_range() { Type::Integer(noirc_frontend::shared::Signedness::Signed, IntegerBitSize::SixtyFour); let start_range = - range_modulo(int_literal(4u64, true, index_type.clone()), index_type.clone(), max_size); + range_modulo(int_literal(9u64, true, index_type.clone()), index_type.clone(), max_size); let end_range = range_modulo(int_literal(1u64, true, index_type.clone()), index_type.clone(), max_size); @@ -76,7 +76,7 @@ fn test_modulo_of_negative_literals_in_range() { let ssa = generate_ssa_from_body(body); - // The upper bound is -1, represented as a field by subtracting it from 1<<64. + // The lower bound is -4 (-9 % 5), represented as a field by subtracting it from u64::MAX. assert_ssa_snapshot!(ssa, @r" acir(inline) fn main f0 { b0(): From c2d40fc1252883b82f44cc74fac6232270b3eb0d Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 17:49:23 +0100 Subject: [PATCH 15/21] Update compiler/noirc_evaluator/src/ssa/ir/integer.rs Co-authored-by: Maxim Vezenov --- compiler/noirc_evaluator/src/ssa/ir/integer.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/ir/integer.rs b/compiler/noirc_evaluator/src/ssa/ir/integer.rs index 38ff4dbbd39..095c9e4c9e4 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/integer.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/integer.rs @@ -101,11 +101,10 @@ impl PartialOrd for IntegerConstant { match (self, other) { (Self::Signed { value: a, .. }, Self::Signed { value: b, .. }) => a.partial_cmp(b), (Self::Signed { value: a, .. }, Self::Unsigned { value: b, .. }) => { - if a.is_negative() || *b > i128::MAX as u128 { + if a.is_negative() { Some(Ordering::Less) } else { - let a: u128 = (*a).try_into().ok()?; - a.partial_cmp(b) + (*a).try_into().ok().and_then(|a: u128| a.partial_cmp(b)) } } (Self::Unsigned { value: a, .. }, Self::Signed { value: b, .. }) => { From 5114996134386460e8db3e480bc5865c9f7cf1ae Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 17:49:48 +0100 Subject: [PATCH 16/21] Update compiler/noirc_evaluator/src/ssa/ir/integer.rs Co-authored-by: Maxim Vezenov --- compiler/noirc_evaluator/src/ssa/ir/integer.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/ir/integer.rs b/compiler/noirc_evaluator/src/ssa/ir/integer.rs index 095c9e4c9e4..44a51dd5578 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/integer.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/integer.rs @@ -111,8 +111,7 @@ impl PartialOrd for IntegerConstant { if b.is_negative() || *a > i128::MAX as u128 { Some(Ordering::Less) } else { - let b: u128 = (*b).try_into().ok()?; - a.partial_cmp(&b) + (*b).try_into().ok().and_then(|b: u128| a.partial_cmp(&b)) } } (Self::Unsigned { value: a, .. }, Self::Unsigned { value: b, .. }) => a.partial_cmp(b), From fee93d9b0306d83dd21d66a7f22dbba1f61e4c1b Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 17:49:57 +0100 Subject: [PATCH 17/21] Update compiler/noirc_evaluator/src/ssa/ir/integer.rs Co-authored-by: Maxim Vezenov --- compiler/noirc_evaluator/src/ssa/ir/integer.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/noirc_evaluator/src/ssa/ir/integer.rs b/compiler/noirc_evaluator/src/ssa/ir/integer.rs index 44a51dd5578..b18fecffa1b 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/integer.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/integer.rs @@ -109,7 +109,7 @@ impl PartialOrd for IntegerConstant { } (Self::Unsigned { value: a, .. }, Self::Signed { value: b, .. }) => { if b.is_negative() || *a > i128::MAX as u128 { - Some(Ordering::Less) + Some(Ordering::Greater) } else { (*b).try_into().ok().and_then(|b: u128| a.partial_cmp(&b)) } From 0f6a4c40d24fae729e53726054692e50aa374746 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 17:50:11 +0100 Subject: [PATCH 18/21] Update compiler/noirc_evaluator/src/ssa/ir/integer.rs Co-authored-by: Maxim Vezenov --- compiler/noirc_evaluator/src/ssa/ir/integer.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/noirc_evaluator/src/ssa/ir/integer.rs b/compiler/noirc_evaluator/src/ssa/ir/integer.rs index b18fecffa1b..9af97c45466 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/integer.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/integer.rs @@ -108,7 +108,7 @@ impl PartialOrd for IntegerConstant { } } (Self::Unsigned { value: a, .. }, Self::Signed { value: b, .. }) => { - if b.is_negative() || *a > i128::MAX as u128 { + if b.is_negative() { Some(Ordering::Greater) } else { (*b).try_into().ok().and_then(|b: u128| a.partial_cmp(&b)) From 34cb742539ce700c85babd81009b01942941bdc9 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 18:06:16 +0100 Subject: [PATCH 19/21] Allow u128 for loop index in AST fuzzer --- tooling/ast_fuzzer/src/program/func.rs | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/tooling/ast_fuzzer/src/program/func.rs b/tooling/ast_fuzzer/src/program/func.rs index 70d4595bc04..4d7b15e2dde 100644 --- a/tooling/ast_fuzzer/src/program/func.rs +++ b/tooling/ast_fuzzer/src/program/func.rs @@ -785,10 +785,16 @@ impl<'a> FunctionContext<'a> { /// Generate a `for` loop. fn gen_for(&mut self, u: &mut Unstructured) -> arbitrary::Result { - // The index can be signed or unsigned int, 8 to 64 bits, + // The index can be signed or unsigned int, 8 to 128 bits, except i128. + let bit_size = + u.choose(&[8, 16, 32, 64, 128]).map(|s| IntegerBitSize::try_from(*s).unwrap())?; let idx_type = Type::Integer( - if bool::arbitrary(u)? { Signedness::Signed } else { Signedness::Unsigned }, - u.choose(&[8, 16, 32, 64]).map(|s| IntegerBitSize::try_from(*s).unwrap())?, + if bit_size == IntegerBitSize::HundredTwentyEight || bool::arbitrary(u)? { + Signedness::Unsigned + } else { + Signedness::Signed + }, + bit_size, ); let (start_range, end_range) = if self.unconstrained() && bool::arbitrary(u)? { From 6e9f7c9838d7e574c1d6e02294be97e76586755c Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 18:47:06 +0100 Subject: [PATCH 20/21] Fix formatting --- compiler/noirc_evaluator/src/ssa/ir/integer.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/noirc_evaluator/src/ssa/ir/integer.rs b/compiler/noirc_evaluator/src/ssa/ir/integer.rs index 9af97c45466..cccd147fee4 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/integer.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/integer.rs @@ -104,7 +104,7 @@ impl PartialOrd for IntegerConstant { if a.is_negative() { Some(Ordering::Less) } else { - (*a).try_into().ok().and_then(|a: u128| a.partial_cmp(b)) + (*a).try_into().ok().and_then(|a: u128| a.partial_cmp(b)) } } (Self::Unsigned { value: a, .. }, Self::Signed { value: b, .. }) => { From 6cee3bf02828c0212888d4457f47f2a2637b2eb7 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 18:49:48 +0100 Subject: [PATCH 21/21] Fix range generator --- tooling/ast_fuzzer/src/program/expr.rs | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/tooling/ast_fuzzer/src/program/expr.rs b/tooling/ast_fuzzer/src/program/expr.rs index f75f72144a1..60a5f0a2a33 100644 --- a/tooling/ast_fuzzer/src/program/expr.rs +++ b/tooling/ast_fuzzer/src/program/expr.rs @@ -141,7 +141,7 @@ pub(crate) fn gen_range( let e = (Field::from(e.unsigned_abs()), e < 0); (s, e) } - _ => unreachable!("invalid bit size for range: {integer_bit_size}"), + _ => unreachable!("invalid bit size for range: {integer_bit_size} (signed)"), } } else { let (s, e) = match integer_bit_size { @@ -173,7 +173,14 @@ pub(crate) fn gen_range( let e = Field::from(e); (s, e) } - _ => unreachable!("invalid bit size for range: {integer_bit_size}"), + HundredTwentyEight => { + let s = u128::arbitrary(u)?; + let e = s.saturating_add(u.choose_index(max_size)? as u128); + let s = Field::from(s); + let e = Field::from(e); + (s, e) + } + _ => unreachable!("invalid bit size for range: {integer_bit_size} (unsigned)"), }; ((s, false), (e, false)) }