From aa25da7b04f75082af62dfae74f11a83de219cdd Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Wed, 16 Apr 2025 00:52:52 +0100 Subject: [PATCH 01/11] Integration test to show that const negative ranges are skipped --- .../execution_success/regression_8011/Nargo.toml | 6 ++++++ .../execution_success/regression_8011/Prover.toml | 1 + .../execution_success/regression_8011/src/main.nr | 9 +++++++++ 3 files changed, 16 insertions(+) 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 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..5a3cd857b1a --- /dev/null +++ b/test_programs/execution_success/regression_8011/src/main.nr @@ -0,0 +1,9 @@ +unconstrained fn main() -> pub u32 { + let s: i64 = -5; + let e: i64 = 10; + let mut sum = 0; + for _ in s..e { + sum += 1; + } + sum +} \ No newline at end of file From 3390656be10a34cb417fe3e8e19b91d13d6c6d8c Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Wed, 16 Apr 2025 01:02:00 +0100 Subject: [PATCH 02/11] Don't skip negative ranges --- .../noirc_evaluator/src/ssa/ssa_gen/mod.rs | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs index 5dd52eff7ae..25b6e109f94 100644 --- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs @@ -28,7 +28,7 @@ use self::{ use super::ir::basic_block::BasicBlockId; use super::ir::dfg::GlobalsGraph; -use super::ir::instruction::ErrorType; +use super::ir::instruction::{ErrorType, binary}; use super::ir::types::NumericType; use super::{ function_builder::data_bus::DataBus, @@ -534,10 +534,19 @@ 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 constant_as_i128 = |id| { + let (value, typ) = + self.builder.current_function.dfg.get_numeric_constant_with_type(id)?; + if matches!(typ, NumericType::NativeField) { + value.try_into_i128() + } else { + binary::try_convert_field_element_to_signed_integer(value, typ.bit_size()) + } + }; + + if let (Some(start_constant), Some(end_constant)) = + (constant_as_i128(start_index), constant_as_i128(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()); From fc2df220e381b0d164ab17d350b809235a5530a2 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Wed, 16 Apr 2025 01:04:42 +0100 Subject: [PATCH 03/11] Add snapshots --- .../regression_8011/stdout.txt | 1 + ...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 +++++++++++++++++++ 7 files changed, 259 insertions(+) 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/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_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..7b67b7ad536 --- /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/7VUwU7DMAxN1nZtGBMILpwQFw5cIGGpWm478CNho9/RT6cBW3WttICaPCly0rw9PztZpBghIeZiCin+ALnw7RWigrgh+9kwjrDW62AUyxtTv9W2VoH6Ivo/KNCUafQ16ifqvy5B570f9WktmLcaxiWZ72G+X/h9Su/D2VpFNGPrDzC3M/49dtCHJ9IHyhVi2kcaBfOM2LC+JapLXy/UFcqdr8jdTfGhiGYMfQaH+kWa3hnU36bxb/AeycDZ+Jx37JxUJB8tW6MHfB8E6HNvNL8fVYCfL/CxtoLwS8KpyD7lP5Ce3MP8Ssy/XzuynwX2Q/VmAX4xU+92hl8y/8h/hOjXLzAP/S9Lli8j/kLngffyP/foW6uf8o7wXa9A0/7cI4+sH/tAaxAsf8H4z7C+IHVgXPUuNc50B9e52p3P9uRumL4HvTux89vaNSfXGPNmzac19W/5vwC1+Ijm9QkAAA==", + "debug_symbols": "lZPNCoQgFIXf5a5dZPnT9CrDEFYWgmiYDQzRu48ODUS0uRvxyPk4wr1ng0F369QaN/oFmucG1vcqGu+S2nYCXTDWmqk9P0ORD8p+/mVWLsslqhCheUgC2g3pUid6NFZDw4v9RYBypF8g/RLnL2//T6k4AErlleBoQqAJiSWq4pYo6z9RiStRojMqdAZDExxNCDQh0USNI/ak3ioY1Vl9VGhcXX9qVPzM+lKuOfheD2vQuWanhuXJMkqYyOtNs5CEPVJGyvkC", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub 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}", + "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..7b67b7ad536 --- /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/7VUwU7DMAxN1nZtGBMILpwQFw5cIGGpWm478CNho9/RT6cBW3WttICaPCly0rw9PztZpBghIeZiCin+ALnw7RWigrgh+9kwjrDW62AUyxtTv9W2VoH6Ivo/KNCUafQ16ifqvy5B570f9WktmLcaxiWZ72G+X/h9Su/D2VpFNGPrDzC3M/49dtCHJ9IHyhVi2kcaBfOM2LC+JapLXy/UFcqdr8jdTfGhiGYMfQaH+kWa3hnU36bxb/AeycDZ+Jx37JxUJB8tW6MHfB8E6HNvNL8fVYCfL/CxtoLwS8KpyD7lP5Ce3MP8Ssy/XzuynwX2Q/VmAX4xU+92hl8y/8h/hOjXLzAP/S9Lli8j/kLngffyP/foW6uf8o7wXa9A0/7cI4+sH/tAaxAsf8H4z7C+IHVgXPUuNc50B9e52p3P9uRumL4HvTux89vaNSfXGPNmzac19W/5vwC1+Ijm9QkAAA==", + "debug_symbols": "lZPNCoQgFIXf5a5dZPnT9CrDEFYWgmiYDQzRu48ODUS0uRvxyPk4wr1ng0F369QaN/oFmucG1vcqGu+S2nYCXTDWmqk9P0ORD8p+/mVWLsslqhCheUgC2g3pUid6NFZDw4v9RYBypF8g/RLnL2//T6k4AErlleBoQqAJiSWq4pYo6z9RiStRojMqdAZDExxNCDQh0USNI/ak3ioY1Vl9VGhcXX9qVPzM+lKuOfheD2vQuWanhuXJMkqYyOtNs5CEPVJGyvkC", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub 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}", + "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..7b67b7ad536 --- /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/7VUwU7DMAxN1nZtGBMILpwQFw5cIGGpWm478CNho9/RT6cBW3WttICaPCly0rw9PztZpBghIeZiCin+ALnw7RWigrgh+9kwjrDW62AUyxtTv9W2VoH6Ivo/KNCUafQ16ifqvy5B570f9WktmLcaxiWZ72G+X/h9Su/D2VpFNGPrDzC3M/49dtCHJ9IHyhVi2kcaBfOM2LC+JapLXy/UFcqdr8jdTfGhiGYMfQaH+kWa3hnU36bxb/AeycDZ+Jx37JxUJB8tW6MHfB8E6HNvNL8fVYCfL/CxtoLwS8KpyD7lP5Ce3MP8Ssy/XzuynwX2Q/VmAX4xU+92hl8y/8h/hOjXLzAP/S9Lli8j/kLngffyP/foW6uf8o7wXa9A0/7cI4+sH/tAaxAsf8H4z7C+IHVgXPUuNc50B9e52p3P9uRumL4HvTux89vaNSfXGPNmzac19W/5vwC1+Ijm9QkAAA==", + "debug_symbols": "lZPNCoQgFIXf5a5dZPnT9CrDEFYWgmiYDQzRu48ODUS0uRvxyPk4wr1ng0F369QaN/oFmucG1vcqGu+S2nYCXTDWmqk9P0ORD8p+/mVWLsslqhCheUgC2g3pUid6NFZDw4v9RYBypF8g/RLnL2//T6k4AErlleBoQqAJiSWq4pYo6z9RiStRojMqdAZDExxNCDQh0USNI/ak3ioY1Vl9VGhcXX9qVPzM+lKuOfheD2vQuWanhuXJMkqYyOtNs5CEPVJGyvkC", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub 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}", + "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..7b67b7ad536 --- /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/7VUwU7DMAxN1nZtGBMILpwQFw5cIGGpWm478CNho9/RT6cBW3WttICaPCly0rw9PztZpBghIeZiCin+ALnw7RWigrgh+9kwjrDW62AUyxtTv9W2VoH6Ivo/KNCUafQ16ifqvy5B570f9WktmLcaxiWZ72G+X/h9Su/D2VpFNGPrDzC3M/49dtCHJ9IHyhVi2kcaBfOM2LC+JapLXy/UFcqdr8jdTfGhiGYMfQaH+kWa3hnU36bxb/AeycDZ+Jx37JxUJB8tW6MHfB8E6HNvNL8fVYCfL/CxtoLwS8KpyD7lP5Ce3MP8Ssy/XzuynwX2Q/VmAX4xU+92hl8y/8h/hOjXLzAP/S9Lli8j/kLngffyP/foW6uf8o7wXa9A0/7cI4+sH/tAaxAsf8H4z7C+IHVgXPUuNc50B9e52p3P9uRumL4HvTux89vaNSfXGPNmzac19W/5vwC1+Ijm9QkAAA==", + "debug_symbols": "lZPNCoQgFIXf5a5dZPnT9CrDEFYWgmiYDQzRu48ODUS0uRvxyPk4wr1ng0F369QaN/oFmucG1vcqGu+S2nYCXTDWmqk9P0ORD8p+/mVWLsslqhCheUgC2g3pUid6NFZDw4v9RYBypF8g/RLnL2//T6k4AErlleBoQqAJiSWq4pYo6z9RiStRojMqdAZDExxNCDQh0USNI/ak3ioY1Vl9VGhcXX9qVPzM+lKuOfheD2vQuWanhuXJMkqYyOtNs5CEPVJGyvkC", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub 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}", + "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..7b67b7ad536 --- /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/7VUwU7DMAxN1nZtGBMILpwQFw5cIGGpWm478CNho9/RT6cBW3WttICaPCly0rw9PztZpBghIeZiCin+ALnw7RWigrgh+9kwjrDW62AUyxtTv9W2VoH6Ivo/KNCUafQ16ifqvy5B570f9WktmLcaxiWZ72G+X/h9Su/D2VpFNGPrDzC3M/49dtCHJ9IHyhVi2kcaBfOM2LC+JapLXy/UFcqdr8jdTfGhiGYMfQaH+kWa3hnU36bxb/AeycDZ+Jx37JxUJB8tW6MHfB8E6HNvNL8fVYCfL/CxtoLwS8KpyD7lP5Ce3MP8Ssy/XzuynwX2Q/VmAX4xU+92hl8y/8h/hOjXLzAP/S9Lli8j/kLngffyP/foW6uf8o7wXa9A0/7cI4+sH/tAaxAsf8H4z7C+IHVgXPUuNc50B9e52p3P9uRumL4HvTux89vaNSfXGPNmzac19W/5vwC1+Ijm9QkAAA==", + "debug_symbols": "lZPNCoQgFIXf5a5dZPnT9CrDEFYWgmiYDQzRu48ODUS0uRvxyPk4wr1ng0F369QaN/oFmucG1vcqGu+S2nYCXTDWmqk9P0ORD8p+/mVWLsslqhCheUgC2g3pUid6NFZDw4v9RYBypF8g/RLnL2//T6k4AErlleBoQqAJiSWq4pYo6z9RiStRojMqdAZDExxNCDQh0USNI/ak3ioY1Vl9VGhcXX9qVPzM+lKuOfheD2vQuWanhuXJMkqYyOtNs5CEPVJGyvkC", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub 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}", + "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..7b67b7ad536 --- /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/7VUwU7DMAxN1nZtGBMILpwQFw5cIGGpWm478CNho9/RT6cBW3WttICaPCly0rw9PztZpBghIeZiCin+ALnw7RWigrgh+9kwjrDW62AUyxtTv9W2VoH6Ivo/KNCUafQ16ifqvy5B570f9WktmLcaxiWZ72G+X/h9Su/D2VpFNGPrDzC3M/49dtCHJ9IHyhVi2kcaBfOM2LC+JapLXy/UFcqdr8jdTfGhiGYMfQaH+kWa3hnU36bxb/AeycDZ+Jx37JxUJB8tW6MHfB8E6HNvNL8fVYCfL/CxtoLwS8KpyD7lP5Ce3MP8Ssy/XzuynwX2Q/VmAX4xU+92hl8y/8h/hOjXLzAP/S9Lli8j/kLngffyP/foW6uf8o7wXa9A0/7cI4+sH/tAaxAsf8H4z7C+IHVgXPUuNc50B9e52p3P9uRumL4HvTux89vaNSfXGPNmzac19W/5vwC1+Ijm9QkAAA==", + "debug_symbols": "lZPNCoQgFIXf5a5dZPnT9CrDEFYWgmiYDQzRu48ODUS0uRvxyPk4wr1ng0F369QaN/oFmucG1vcqGu+S2nYCXTDWmqk9P0ORD8p+/mVWLsslqhCheUgC2g3pUid6NFZDw4v9RYBypF8g/RLnL2//T6k4AErlleBoQqAJiSWq4pYo6z9RiStRojMqdAZDExxNCDQh0USNI/ak3ioY1Vl9VGhcXX9qVPzM+lKuOfheD2vQuWanhuXJMkqYyOtNs5CEPVJGyvkC", + "file_map": { + "50": { + "source": "unconstrained fn main() -> pub 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}", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} From 642015b75cf2729e32c5dbf40a21e59e6d013838 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 11:13:08 +0100 Subject: [PATCH 04/11] Add IntegerConstant --- compiler/noirc_evaluator/src/ssa/ir/dfg.rs | 12 +++++- .../noirc_evaluator/src/ssa/ir/integer.rs | 39 +++++++++++++++++++ compiler/noirc_evaluator/src/ssa/ir/mod.rs | 1 + .../noirc_evaluator/src/ssa/ssa_gen/mod.rs | 19 ++++----- .../regression_8011/src/main.nr | 17 ++++++++ 5 files changed, 75 insertions(+), 13 deletions(-) create mode 100644 compiler/noirc_evaluator/src/ssa/ir/integer.rs diff --git a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs index ad386b6e6df..802aba6c749 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, resolve_value}, @@ -595,11 +596,20 @@ 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. pub(crate) fn get_numeric_constant_with_type( 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..ff5241d61c2 --- /dev/null +++ b/compiler/noirc_evaluator/src/ssa/ir/integer.rs @@ -0,0 +1,39 @@ +use acvm::{AcirField, FieldElement}; + +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. +#[derive(Debug, Clone)] +pub(crate) enum IntegerConstant { + Signed(i128), + Unsigned(u128), +} + +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(Self::Signed) + } + NumericType::Unsigned { .. } => Some(Self::Unsigned(field.to_u128())), + NumericType::NativeField => None, + } + } + + /// Apply functions on two numeric types, or return `None` if they have different signedness. + 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(a), Self::Signed(b)) => Some(s(*a, *b)), + (Self::Unsigned(a), Self::Unsigned(b)) => Some(u(*a, *b)), + _ => None, + } + } +} diff --git a/compiler/noirc_evaluator/src/ssa/ir/mod.rs b/compiler/noirc_evaluator/src/ssa/ir/mod.rs index 686606452fb..d1f5bde6b80 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(crate) mod function; pub(crate) mod function_inserter; pub(crate) mod instruction; +pub(crate) mod integer; pub(crate) mod map; pub(crate) mod post_order; pub(crate) mod printer; diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs index 25b6e109f94..a9dc23772f7 100644 --- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs @@ -28,7 +28,7 @@ use self::{ use super::ir::basic_block::BasicBlockId; use super::ir::dfg::GlobalsGraph; -use super::ir::instruction::{ErrorType, binary}; +use super::ir::instruction::ErrorType; use super::ir::types::NumericType; use super::{ function_builder::data_bus::DataBus, @@ -534,21 +534,16 @@ impl FunctionContext<'_> { self.builder.set_location(for_expr.end_range_location); let end_index = self.codegen_non_tuple_expression(&for_expr.end_range)?; - let constant_as_i128 = |id| { - let (value, typ) = - self.builder.current_function.dfg.get_numeric_constant_with_type(id)?; - if matches!(typ, NumericType::NativeField) { - value.try_into_i128() - } else { - binary::try_convert_field_element_to_signed_integer(value, typ.bit_size()) - } - }; + let range_bound = |id| self.builder.current_function.dfg.get_integer_constant(id); if let (Some(start_constant), Some(end_constant)) = - (constant_as_i128(start_index), constant_as_i128(end_index)) + (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 { + if start_constant + .reduce(&end_constant, |s, e| s >= e, |s, e| s >= e) + .unwrap_or_default() + { return Ok(Self::unit_value()); } } diff --git a/test_programs/execution_success/regression_8011/src/main.nr b/test_programs/execution_success/regression_8011/src/main.nr index 5a3cd857b1a..12dc9e62d93 100644 --- a/test_programs/execution_success/regression_8011/src/main.nr +++ b/test_programs/execution_success/regression_8011/src/main.nr @@ -1,4 +1,11 @@ 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; @@ -6,4 +13,14 @@ unconstrained fn main() -> pub u32 { sum += 1; } sum +} + +fn loop_with_u128_literal() -> u32 { + let s: u128 = 170141183460469231731687303715884105715; + let e: u128 = 170141183460469231731687303715884105730; + let mut sum = 0; + for i in s..e { + sum += 1; + } + sum } \ No newline at end of file From da218e00901f395a7f76567909488dcd34d0a067 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 11:35:00 +0100 Subject: [PATCH 05/11] Use IntegerConstant::reduce in unrolling --- .../noirc_evaluator/src/ssa/ir/integer.rs | 18 ++++-- .../noirc_evaluator/src/ssa/opt/unrolling.rs | 56 +++++++++---------- .../noirc_evaluator/src/ssa/ssa_gen/mod.rs | 4 +- 3 files changed, 39 insertions(+), 39 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/ir/integer.rs b/compiler/noirc_evaluator/src/ssa/ir/integer.rs index ff5241d61c2..a403ede5de4 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/integer.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/integer.rs @@ -5,7 +5,7 @@ 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. -#[derive(Debug, Clone)] +#[derive(Debug, Clone, Copy, PartialEq, Eq)] pub(crate) enum IntegerConstant { Signed(i128), Unsigned(u128), @@ -25,15 +25,23 @@ impl IntegerConstant { /// Apply functions on two numeric types, or return `None` if they have different signedness. pub(crate) fn reduce( - &self, - other: &Self, + self, + other: Self, s: impl Fn(i128, i128) -> T, u: impl Fn(u128, u128) -> T, ) -> Option { match (self, other) { - (Self::Signed(a), Self::Signed(b)) => Some(s(*a, *b)), - (Self::Unsigned(a), Self::Unsigned(b)) => Some(u(*a, *b)), + (Self::Signed(a), Self::Signed(b)) => Some(s(a, b)), + (Self::Unsigned(a), Self::Unsigned(b)) => Some(u(a, b)), _ => None, } } + + /// Increment the value by 1, saturating at the maximum value. + pub(crate) fn inc(self) -> Self { + match self { + IntegerConstant::Signed(x) => Self::Signed(x.saturating_add(1)), + IntegerConstant::Unsigned(x) => Self::Unsigned(x.saturating_add(1)), + } + } } diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs index 38f8dbbf606..7581e75bac1 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)) @@ -695,13 +685,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 }) } } @@ -1042,6 +1035,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}; @@ -1168,8 +1162,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(0)); + assert_eq!(upper, IntegerConstant::Unsigned(4)); } #[test] diff --git a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs index a9dc23772f7..c650f98caf9 100644 --- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs @@ -540,9 +540,7 @@ impl FunctionContext<'_> { (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 - .reduce(&end_constant, |s, e| s >= e, |s, e| s >= e) - .unwrap_or_default() + if start_constant.reduce(end_constant, |s, e| s >= e, |s, e| s >= e).unwrap_or_default() { return Ok(Self::unit_value()); } From 562911dabd7b22f55f48b6a1c3e37de07cb2ea84 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 12:58:08 +0100 Subject: [PATCH 06/11] Use IntegerConstant in loop invariant hoisting --- .../noirc_evaluator/src/ssa/ir/integer.rs | 92 +++++++++++++++++-- .../src/ssa/opt/loop_invariant.rs | 48 +++++----- .../noirc_evaluator/src/ssa/opt/unrolling.rs | 4 +- .../noirc_evaluator/src/ssa/ssa_gen/mod.rs | 3 +- .../regression_8011/src/main.nr | 2 +- 5 files changed, 112 insertions(+), 37 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/ir/integer.rs b/compiler/noirc_evaluator/src/ssa/ir/integer.rs index a403ede5de4..3d6a14e0188 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/integer.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/integer.rs @@ -1,4 +1,7 @@ +use std::cmp::Ordering; + use acvm::{AcirField, FieldElement}; +use num_traits::Zero; use super::{instruction::binary, types::NumericType}; @@ -7,8 +10,8 @@ use super::{instruction::binary, types::NumericType}; /// This type can be used in loops and other instances where values have to be compared. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub(crate) enum IntegerConstant { - Signed(i128), - Unsigned(u128), + Signed { value: i128, bit_size: u32 }, + Unsigned { value: u128, bit_size: u32 }, } impl IntegerConstant { @@ -16,14 +19,29 @@ impl IntegerConstant { match typ { NumericType::Signed { bit_size } => { binary::try_convert_field_element_to_signed_integer(field, bit_size) - .map(Self::Signed) + .map(|value| Self::Signed { value, bit_size }) + } + NumericType::Unsigned { bit_size } => { + Some(Self::Unsigned { value: field.to_u128(), bit_size }) } - NumericType::Unsigned { .. } => Some(Self::Unsigned(field.to_u128())), NumericType::NativeField => None, } } - /// Apply functions on two numeric types, or return `None` if they have different signedness. + /// 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, @@ -31,17 +49,73 @@ impl IntegerConstant { u: impl Fn(u128, u128) -> T, ) -> Option { match (self, other) { - (Self::Signed(a), Self::Signed(b)) => Some(s(a, b)), - (Self::Unsigned(a), Self::Unsigned(b)) => Some(u(a, b)), + (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 { - IntegerConstant::Signed(x) => Self::Signed(x.saturating_add(1)), - IntegerConstant::Unsigned(x) => Self::Unsigned(x.saturating_add(1)), + 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/opt/loop_invariant.rs b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs index 6e067a9b04e..5b1fe190784 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}, @@ -137,11 +138,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. @@ -367,9 +368,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 { @@ -398,7 +396,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 } @@ -410,7 +408,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. @@ -575,13 +575,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)); } @@ -635,9 +635,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, @@ -650,10 +650,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, @@ -706,6 +706,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 { @@ -732,7 +734,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, @@ -759,10 +761,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 7581e75bac1..7c2f3d57198 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs @@ -1162,8 +1162,8 @@ mod tests { let (lower, upper) = loop_.get_const_bounds(function, pre_header).expect("bounds are numeric const"); - assert_eq!(lower, IntegerConstant::Unsigned(0)); - assert_eq!(upper, IntegerConstant::Unsigned(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 c650f98caf9..9a10f4e1b5c 100644 --- a/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs @@ -540,8 +540,7 @@ impl FunctionContext<'_> { (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.reduce(end_constant, |s, e| s >= e, |s, e| s >= e).unwrap_or_default() - { + if start_constant >= end_constant { return Ok(Self::unit_value()); } } diff --git a/test_programs/execution_success/regression_8011/src/main.nr b/test_programs/execution_success/regression_8011/src/main.nr index 12dc9e62d93..5cc4623a727 100644 --- a/test_programs/execution_success/regression_8011/src/main.nr +++ b/test_programs/execution_success/regression_8011/src/main.nr @@ -19,7 +19,7 @@ fn loop_with_u128_literal() -> u32 { let s: u128 = 170141183460469231731687303715884105715; let e: u128 = 170141183460469231731687303715884105730; let mut sum = 0; - for i in s..e { + for _ in s..e { sum += 1; } sum From b5ed3078e9aa1b2584f5f3858039be9694d40af9 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 13:00:28 +0100 Subject: [PATCH 07/11] Update insta --- ...s__force_brillig_false_inliner_-9223372036854775808.snap | 4 ++-- .../execute__tests__force_brillig_false_inliner_0.snap | 4 ++-- ...ts__force_brillig_false_inliner_9223372036854775807.snap | 4 ++-- ...ts__force_brillig_true_inliner_-9223372036854775808.snap | 4 ++-- .../execute__tests__force_brillig_true_inliner_0.snap | 4 ++-- ...sts__force_brillig_true_inliner_9223372036854775807.snap | 4 ++-- ...s__force_brillig_false_inliner_-9223372036854775808.snap | 6 +++--- .../execute__tests__force_brillig_false_inliner_0.snap | 6 +++--- ...ts__force_brillig_false_inliner_9223372036854775807.snap | 6 +++--- ...ts__force_brillig_true_inliner_-9223372036854775808.snap | 6 +++--- .../execute__tests__force_brillig_true_inliner_0.snap | 6 +++--- ...sts__force_brillig_true_inliner_9223372036854775807.snap | 6 +++--- 12 files changed, 30 insertions(+), 30 deletions(-) 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 index 7b67b7ad536..d7aa5c2c874 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 @@ -26,11 +26,11 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/7VUwU7DMAxN1nZtGBMILpwQFw5cIGGpWm478CNho9/RT6cBW3WttICaPCly0rw9PztZpBghIeZiCin+ALnw7RWigrgh+9kwjrDW62AUyxtTv9W2VoH6Ivo/KNCUafQ16ifqvy5B570f9WktmLcaxiWZ72G+X/h9Su/D2VpFNGPrDzC3M/49dtCHJ9IHyhVi2kcaBfOM2LC+JapLXy/UFcqdr8jdTfGhiGYMfQaH+kWa3hnU36bxb/AeycDZ+Jx37JxUJB8tW6MHfB8E6HNvNL8fVYCfL/CxtoLwS8KpyD7lP5Ce3MP8Ssy/XzuynwX2Q/VmAX4xU+92hl8y/8h/hOjXLzAP/S9Lli8j/kLngffyP/foW6uf8o7wXa9A0/7cI4+sH/tAaxAsf8H4z7C+IHVgXPUuNc50B9e52p3P9uRumL4HvTux89vaNSfXGPNmzac19W/5vwC1+Ijm9QkAAA==", - "debug_symbols": "lZPNCoQgFIXf5a5dZPnT9CrDEFYWgmiYDQzRu48ODUS0uRvxyPk4wr1ng0F369QaN/oFmucG1vcqGu+S2nYCXTDWmqk9P0ORD8p+/mVWLsslqhCheUgC2g3pUid6NFZDw4v9RYBypF8g/RLnL2//T6k4AErlleBoQqAJiSWq4pYo6z9RiStRojMqdAZDExxNCDQh0USNI/ak3ioY1Vl9VGhcXX9qVPzM+lKuOfheD2vQuWanhuXJMkqYyOtNs5CEPVJGyvkC", + "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 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}", + "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": "" } }, 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 7b67b7ad536..f9a2396ef70 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 @@ -26,11 +26,11 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/7VUwU7DMAxN1nZtGBMILpwQFw5cIGGpWm478CNho9/RT6cBW3WttICaPCly0rw9PztZpBghIeZiCin+ALnw7RWigrgh+9kwjrDW62AUyxtTv9W2VoH6Ivo/KNCUafQ16ifqvy5B570f9WktmLcaxiWZ72G+X/h9Su/D2VpFNGPrDzC3M/49dtCHJ9IHyhVi2kcaBfOM2LC+JapLXy/UFcqdr8jdTfGhiGYMfQaH+kWa3hnU36bxb/AeycDZ+Jx37JxUJB8tW6MHfB8E6HNvNL8fVYCfL/CxtoLwS8KpyD7lP5Ce3MP8Ssy/XzuynwX2Q/VmAX4xU+92hl8y/8h/hOjXLzAP/S9Lli8j/kLngffyP/foW6uf8o7wXa9A0/7cI4+sH/tAaxAsf8H4z7C+IHVgXPUuNc50B9e52p3P9uRumL4HvTux89vaNSfXGPNmzac19W/5vwC1+Ijm9QkAAA==", - "debug_symbols": "lZPNCoQgFIXf5a5dZPnT9CrDEFYWgmiYDQzRu48ODUS0uRvxyPk4wr1ng0F369QaN/oFmucG1vcqGu+S2nYCXTDWmqk9P0ORD8p+/mVWLsslqhCheUgC2g3pUid6NFZDw4v9RYBypF8g/RLnL2//T6k4AErlleBoQqAJiSWq4pYo6z9RiStRojMqdAZDExxNCDQh0USNI/ak3ioY1Vl9VGhcXX9qVPzM+lKuOfheD2vQuWanhuXJMkqYyOtNs5CEPVJGyvkC", + "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 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}", + "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": "" } }, 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 7b67b7ad536..f9a2396ef70 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 @@ -26,11 +26,11 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/7VUwU7DMAxN1nZtGBMILpwQFw5cIGGpWm478CNho9/RT6cBW3WttICaPCly0rw9PztZpBghIeZiCin+ALnw7RWigrgh+9kwjrDW62AUyxtTv9W2VoH6Ivo/KNCUafQ16ifqvy5B570f9WktmLcaxiWZ72G+X/h9Su/D2VpFNGPrDzC3M/49dtCHJ9IHyhVi2kcaBfOM2LC+JapLXy/UFcqdr8jdTfGhiGYMfQaH+kWa3hnU36bxb/AeycDZ+Jx37JxUJB8tW6MHfB8E6HNvNL8fVYCfL/CxtoLwS8KpyD7lP5Ce3MP8Ssy/XzuynwX2Q/VmAX4xU+92hl8y/8h/hOjXLzAP/S9Lli8j/kLngffyP/foW6uf8o7wXa9A0/7cI4+sH/tAaxAsf8H4z7C+IHVgXPUuNc50B9e52p3P9uRumL4HvTux89vaNSfXGPNmzac19W/5vwC1+Ijm9QkAAA==", - "debug_symbols": "lZPNCoQgFIXf5a5dZPnT9CrDEFYWgmiYDQzRu48ODUS0uRvxyPk4wr1ng0F369QaN/oFmucG1vcqGu+S2nYCXTDWmqk9P0ORD8p+/mVWLsslqhCheUgC2g3pUid6NFZDw4v9RYBypF8g/RLnL2//T6k4AErlleBoQqAJiSWq4pYo6z9RiStRojMqdAZDExxNCDQh0USNI/ak3ioY1Vl9VGhcXX9qVPzM+lKuOfheD2vQuWanhuXJMkqYyOtNs5CEPVJGyvkC", + "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 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}", + "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": "" } }, 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 7b67b7ad536..d7aa5c2c874 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 @@ -26,11 +26,11 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/7VUwU7DMAxN1nZtGBMILpwQFw5cIGGpWm478CNho9/RT6cBW3WttICaPCly0rw9PztZpBghIeZiCin+ALnw7RWigrgh+9kwjrDW62AUyxtTv9W2VoH6Ivo/KNCUafQ16ifqvy5B570f9WktmLcaxiWZ72G+X/h9Su/D2VpFNGPrDzC3M/49dtCHJ9IHyhVi2kcaBfOM2LC+JapLXy/UFcqdr8jdTfGhiGYMfQaH+kWa3hnU36bxb/AeycDZ+Jx37JxUJB8tW6MHfB8E6HNvNL8fVYCfL/CxtoLwS8KpyD7lP5Ce3MP8Ssy/XzuynwX2Q/VmAX4xU+92hl8y/8h/hOjXLzAP/S9Lli8j/kLngffyP/foW6uf8o7wXa9A0/7cI4+sH/tAaxAsf8H4z7C+IHVgXPUuNc50B9e52p3P9uRumL4HvTux89vaNSfXGPNmzac19W/5vwC1+Ijm9QkAAA==", - "debug_symbols": "lZPNCoQgFIXf5a5dZPnT9CrDEFYWgmiYDQzRu48ODUS0uRvxyPk4wr1ng0F369QaN/oFmucG1vcqGu+S2nYCXTDWmqk9P0ORD8p+/mVWLsslqhCheUgC2g3pUid6NFZDw4v9RYBypF8g/RLnL2//T6k4AErlleBoQqAJiSWq4pYo6z9RiStRojMqdAZDExxNCDQh0USNI/ak3ioY1Vl9VGhcXX9qVPzM+lKuOfheD2vQuWanhuXJMkqYyOtNs5CEPVJGyvkC", + "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 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}", + "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": "" } }, 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 7b67b7ad536..f9a2396ef70 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 @@ -26,11 +26,11 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/7VUwU7DMAxN1nZtGBMILpwQFw5cIGGpWm478CNho9/RT6cBW3WttICaPCly0rw9PztZpBghIeZiCin+ALnw7RWigrgh+9kwjrDW62AUyxtTv9W2VoH6Ivo/KNCUafQ16ifqvy5B570f9WktmLcaxiWZ72G+X/h9Su/D2VpFNGPrDzC3M/49dtCHJ9IHyhVi2kcaBfOM2LC+JapLXy/UFcqdr8jdTfGhiGYMfQaH+kWa3hnU36bxb/AeycDZ+Jx37JxUJB8tW6MHfB8E6HNvNL8fVYCfL/CxtoLwS8KpyD7lP5Ce3MP8Ssy/XzuynwX2Q/VmAX4xU+92hl8y/8h/hOjXLzAP/S9Lli8j/kLngffyP/foW6uf8o7wXa9A0/7cI4+sH/tAaxAsf8H4z7C+IHVgXPUuNc50B9e52p3P9uRumL4HvTux89vaNSfXGPNmzac19W/5vwC1+Ijm9QkAAA==", - "debug_symbols": "lZPNCoQgFIXf5a5dZPnT9CrDEFYWgmiYDQzRu48ODUS0uRvxyPk4wr1ng0F369QaN/oFmucG1vcqGu+S2nYCXTDWmqk9P0ORD8p+/mVWLsslqhCheUgC2g3pUid6NFZDw4v9RYBypF8g/RLnL2//T6k4AErlleBoQqAJiSWq4pYo6z9RiStRojMqdAZDExxNCDQh0USNI/ak3ioY1Vl9VGhcXX9qVPzM+lKuOfheD2vQuWanhuXJMkqYyOtNs5CEPVJGyvkC", + "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 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}", + "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": "" } }, 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 7b67b7ad536..f9a2396ef70 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 @@ -26,11 +26,11 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/7VUwU7DMAxN1nZtGBMILpwQFw5cIGGpWm478CNho9/RT6cBW3WttICaPCly0rw9PztZpBghIeZiCin+ALnw7RWigrgh+9kwjrDW62AUyxtTv9W2VoH6Ivo/KNCUafQ16ifqvy5B570f9WktmLcaxiWZ72G+X/h9Su/D2VpFNGPrDzC3M/49dtCHJ9IHyhVi2kcaBfOM2LC+JapLXy/UFcqdr8jdTfGhiGYMfQaH+kWa3hnU36bxb/AeycDZ+Jx37JxUJB8tW6MHfB8E6HNvNL8fVYCfL/CxtoLwS8KpyD7lP5Ce3MP8Ssy/XzuynwX2Q/VmAX4xU+92hl8y/8h/hOjXLzAP/S9Lli8j/kLngffyP/foW6uf8o7wXa9A0/7cI4+sH/tAaxAsf8H4z7C+IHVgXPUuNc50B9e52p3P9uRumL4HvTux89vaNSfXGPNmzac19W/5vwC1+Ijm9QkAAA==", - "debug_symbols": "lZPNCoQgFIXf5a5dZPnT9CrDEFYWgmiYDQzRu48ODUS0uRvxyPk4wr1ng0F369QaN/oFmucG1vcqGu+S2nYCXTDWmqk9P0ORD8p+/mVWLsslqhCheUgC2g3pUid6NFZDw4v9RYBypF8g/RLnL2//T6k4AErlleBoQqAJiSWq4pYo6z9RiStRojMqdAZDExxNCDQh0USNI/ak3ioY1Vl9VGhcXX9qVPzM+lKuOfheD2vQuWanhuXJMkqYyOtNs5CEPVJGyvkC", + "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 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}", + "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": "" } }, From 66151b226f9ae8500ab3932c0d431eedb94ab18f Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 13:07:16 +0100 Subject: [PATCH 08/11] Fix docs --- compiler/noirc_evaluator/src/ssa/ir/dfg.rs | 4 ++-- compiler/noirc_evaluator/src/ssa/ir/integer.rs | 5 +++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs index cc7eaaf6ebb..fbd05470714 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/dfg.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/dfg.rs @@ -583,7 +583,7 @@ 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 { @@ -598,7 +598,7 @@ impl DataFlowGraph { } /// 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 index 3d6a14e0188..38ff4dbbd39 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/integer.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/integer.rs @@ -5,9 +5,10 @@ use num_traits::Zero; use super::{instruction::binary, types::NumericType}; -/// A `Signed` or `Unsigned` value of a [Value::NumericConstant], converted to 128 bits. +/// 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. +/// 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 }, From d0953874ac305d58ed59fcd11375a571f0a86593 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 13:13:21 +0100 Subject: [PATCH 09/11] nargo fmt --- test_programs/execution_success/regression_8011/src/main.nr | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test_programs/execution_success/regression_8011/src/main.nr b/test_programs/execution_success/regression_8011/src/main.nr index 5cc4623a727..e683b84ecd1 100644 --- a/test_programs/execution_success/regression_8011/src/main.nr +++ b/test_programs/execution_success/regression_8011/src/main.nr @@ -23,4 +23,4 @@ fn loop_with_u128_literal() -> u32 { sum += 1; } sum -} \ No newline at end of file +} From b3994d7bd95d6dba5df6af9046f81b2558bd3bc2 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 13:19:16 +0100 Subject: [PATCH 10/11] Fix is_zero checks --- compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs index 22377f4d315..c0e7f91f6c1 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/loop_invariant.rs @@ -576,7 +576,7 @@ impl<'f> LoopInvariantContext<'f> { _ => None, }?; - assert!(upper.is_zero(), "executing a non executable loop"); + 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(); @@ -762,10 +762,10 @@ impl<'f> LoopInvariantContext<'f> { return false; }; if left { - if value.is_zero() { + if !value.is_zero() { return true; } - } else if lower.is_zero() { + } else if !lower.is_zero() { return true; } From 02d81e072a4ab39dce107b3742cc32d22850705c Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 22 Apr 2025 13:20:45 +0100 Subject: [PATCH 11/11] Fix comment --- compiler/noirc_evaluator/src/ssa/opt/unrolling.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs index 452d2049c68..4d677848217 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs @@ -687,7 +687,7 @@ impl Loop { let increments = self.count_induction_increments(function); let all_instructions = self.count_all_instructions(function); - // Currently we don't iterate in reverse, so if upper >= lower it means 0 iterations. + // Currently we don't iterate in reverse, so if upper <= lower it means 0 iterations. let iterations: usize = upper .reduce( lower,