diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs index a52e50827dd..997d34441ac 100644 --- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs +++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs @@ -1616,28 +1616,47 @@ impl<'block, Registers: RegisterAllocator> BrilligBlock<'block, Registers> { self.brillig_context.codegen_branch(left_is_negative.address, |ctx, is_negative| { if is_negative { - let one = ctx.make_constant_instruction(1_u128.into(), left.bit_size); - - // computes 2^right - let two = ctx.make_constant_instruction(2_u128.into(), left.bit_size); - let two_pow = ctx.make_constant_instruction(1_u128.into(), left.bit_size); - let right_u32 = SingleAddrVariable::new(ctx.allocate_register(), 32); - ctx.cast(right_u32, right); - let pow_body = |ctx: &mut BrilligContext<_, _>, _: SingleAddrVariable| { - ctx.binary_instruction(two_pow, two, two_pow, BrilligBinaryOp::Mul); - }; - ctx.codegen_for_loop(None, right_u32.address, None, pow_body); - - // Right shift using division on 1-complement - ctx.binary_instruction(left, one, result, BrilligBinaryOp::Add); - ctx.convert_signed_division(result, two_pow, result); - ctx.binary_instruction(result, one, result, BrilligBinaryOp::Sub); - - // Clean-up - ctx.deallocate_single_addr(one); - ctx.deallocate_single_addr(two); - ctx.deallocate_single_addr(two_pow); - ctx.deallocate_single_addr(right_u32); + // If right value is greater than the left bit size, return 0 + let rhs_does_not_overflow = SingleAddrVariable::new(ctx.allocate_register(), 1); + let lhs_bit_size = + ctx.make_constant_instruction(left.bit_size.into(), right.bit_size); + ctx.binary_instruction( + right, + lhs_bit_size, + rhs_does_not_overflow, + BrilligBinaryOp::LessThan, + ); + + ctx.codegen_branch(rhs_does_not_overflow.address, |ctx, no_overflow| { + if no_overflow { + let one = ctx.make_constant_instruction(1_u128.into(), left.bit_size); + + // computes 2^right + let two = ctx.make_constant_instruction(2_u128.into(), left.bit_size); + let two_pow = ctx.make_constant_instruction(1_u128.into(), left.bit_size); + let right_u32 = SingleAddrVariable::new(ctx.allocate_register(), 32); + ctx.cast(right_u32, right); + let pow_body = |ctx: &mut BrilligContext<_, _>, _: SingleAddrVariable| { + ctx.binary_instruction(two_pow, two, two_pow, BrilligBinaryOp::Mul); + }; + ctx.codegen_for_loop(None, right_u32.address, None, pow_body); + + // Right shift using division on 1-complement + ctx.binary_instruction(left, one, result, BrilligBinaryOp::Add); + ctx.convert_signed_division(result, two_pow, result); + ctx.binary_instruction(result, one, result, BrilligBinaryOp::Sub); + + // Clean-up + ctx.deallocate_single_addr(one); + ctx.deallocate_single_addr(two); + ctx.deallocate_single_addr(two_pow); + ctx.deallocate_single_addr(right_u32); + } else { + ctx.const_instruction(result, 0_u128.into()); + } + }); + + ctx.deallocate_single_addr(rhs_does_not_overflow); } else { ctx.binary_instruction(left, right, result, BrilligBinaryOp::Shr); } diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs index 63882ffe032..6b39ccd6109 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs @@ -161,10 +161,21 @@ impl Context<'_, '_, '_> { ) -> ValueId { let lhs_typ = self.context.dfg.type_of_value(lhs).unwrap_numeric(); let base = self.field_constant(FieldElement::from(2_u128)); + let rhs_typ = self.context.dfg.type_of_value(rhs).unwrap_numeric(); + //Check whether rhs is less than the bit_size: if it's not then it will overflow and we will return 0 instead. + let bit_size_value = self.numeric_constant(bit_size as u128, rhs_typ); + let rhs_is_less_than_bit_size = self.insert_binary(rhs, BinaryOp::Lt, bit_size_value); + let rhs_is_less_than_bit_size_with_rhs_typ = + self.insert_cast(rhs_is_less_than_bit_size, rhs_typ); + // Nullify rhs in case of overflow, to ensure that pow returns a value compatible with lhs + let rhs = self.insert_binary( + rhs_is_less_than_bit_size_with_rhs_typ, + BinaryOp::Mul { unchecked: true }, + rhs, + ); let pow = self.pow(base, rhs); - let pow = self.pow_or_max_for_bit_size(pow, rhs, bit_size, lhs_typ); let pow = self.insert_cast(pow, lhs_typ); - if lhs_typ.is_unsigned() { + let result = if lhs_typ.is_unsigned() { // unsigned right bit shift is just a normal division self.insert_binary(lhs, BinaryOp::Div, pow) } else { @@ -198,53 +209,14 @@ impl Context<'_, '_, '_> { lhs_sign_as_int, ); self.insert_truncate(shifted, bit_size, bit_size + 1) - } - } - - /// Returns `pow` or the maximum value allowed for `typ` if 2^rhs is guaranteed to exceed that maximum. - fn pow_or_max_for_bit_size( - &mut self, - pow: ValueId, - rhs: ValueId, - bit_size: u32, - typ: NumericType, - ) -> ValueId { - let max = if typ.is_unsigned() { - if bit_size == 128 { u128::MAX } else { (1_u128 << bit_size) - 1 } - } else { - 1_u128 << (bit_size - 1) }; - let max = self.field_constant(FieldElement::from(max)); - - // Here we check whether rhs is less than the bit_size: if it's not then it will overflow. - // Then we do: - // - // rhs_is_less_than_bit_size = lt rhs, bit_size - // rhs_is_not_less_than_bit_size = not rhs_is_less_than_bit_size - // pow_when_is_less_than_bit_size = rhs_is_less_than_bit_size * pow - // pow_when_is_not_less_than_bit_size = rhs_is_not_less_than_bit_size * max - // pow = add pow_when_is_less_than_bit_size, pow_when_is_not_less_than_bit_size - // - // All operations here are unchecked because they work on field types. - let rhs_typ = self.context.dfg.type_of_value(rhs).unwrap_numeric(); - let bit_size = self.numeric_constant(bit_size as u128, rhs_typ); - let rhs_is_less_than_bit_size = self.insert_binary(rhs, BinaryOp::Lt, bit_size); - let rhs_is_not_less_than_bit_size = self.insert_not(rhs_is_less_than_bit_size); - let rhs_is_less_than_bit_size = - self.insert_cast(rhs_is_less_than_bit_size, NumericType::NativeField); - let rhs_is_not_less_than_bit_size = - self.insert_cast(rhs_is_not_less_than_bit_size, NumericType::NativeField); - let pow_when_is_less_than_bit_size = - self.insert_binary(rhs_is_less_than_bit_size, BinaryOp::Mul { unchecked: true }, pow); - let pow_when_is_not_less_than_bit_size = self.insert_binary( - rhs_is_not_less_than_bit_size, - BinaryOp::Mul { unchecked: true }, - max, - ); + // Returns 0 in case of overflow + let rhs_is_less_than_bit_size_with_lhs_typ = + self.insert_cast(rhs_is_less_than_bit_size, lhs_typ); self.insert_binary( - pow_when_is_less_than_bit_size, - BinaryOp::Add { unchecked: true }, - pow_when_is_not_less_than_bit_size, + rhs_is_less_than_bit_size_with_lhs_typ, + BinaryOp::Mul { unchecked: true }, + result, ) } diff --git a/test_programs/execution_success/bit_shifts_runtime/Prover.toml b/test_programs/execution_success/bit_shifts_runtime/Prover.toml index 7b56d36c9d5..5c4518f1a63 100644 --- a/test_programs/execution_success/bit_shifts_runtime/Prover.toml +++ b/test_programs/execution_success/bit_shifts_runtime/Prover.toml @@ -1,3 +1,4 @@ x = 64 y = 1 z = "-769" +u = -1 \ No newline at end of file diff --git a/test_programs/execution_success/bit_shifts_runtime/src/main.nr b/test_programs/execution_success/bit_shifts_runtime/src/main.nr index 370bb699048..2fb642039fe 100644 --- a/test_programs/execution_success/bit_shifts_runtime/src/main.nr +++ b/test_programs/execution_success/bit_shifts_runtime/src/main.nr @@ -1,10 +1,13 @@ -fn main(x: u64, y: u8, z: i16) { +fn main(x: u64, y: u8, z: i16, u: i64) { // runtime shifts on compile-time known values assert(64 << y == 128); assert(64 >> y == 32); // runtime shifts on runtime values assert(x << y == 128); assert(x >> y == 32); + // regression tests for issue #8176 + assert(u >> (x as u8) == 0); + assert(z >> (x as u8) == 0); // Bit-shift with signed integers let mut a: i8 = y as i8; diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 2732d140050..fc0594deb0a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -33,6 +33,15 @@ expression: artifact "width": 16 }, "visibility": "private" + }, + { + "name": "u", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" } ], "return_type": null, @@ -47,11 +56,11 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pdjLThtJFIDhd/GaRde51CWvMhohAyayZBnk2JFGKO8+VXX6J2SRTXvj84M5n0S7y1h87F4OT7fvj8fz69uP3bd/PnZPl+PpdPz+eHp73l+Pb+f+3Y9fDzu+fLxeDof+rd2X5/vW+/5yOF9338630+lh93N/us0f+vG+P8953V/6s8vD7nB+6bODr8fTYdSvh9/by99Xm6+7aZHPbd+y3jasJ1H2dblzP2/Zb1y61O7bl0U37Esq7Mu9+1uuv7TEfqsb9lX4/VXKln373Ld8377blv1c2S937tct9682W/dtuXd/y/Wzz/vH0pb7x1TY13rf/qbX3zKvv+U798uWtz9rvP/4ptfPavncT3fub/n9Xbh/fNP779d9/2P/3/7V/vl4+ePv3U77W+bDzuajz8c8H8t8rPOxzce0xEgxJEbspwBSCCmIFEYKJIUioUgoEoqEIqFIKBKKhCKhSCgaioaioWgoGoqGoqFoKBqKhmKhWCgWiq1XJBQLxUKxUCwUC8VD8VA8FA/F1wsbiofiXemHzLvS71Vvc+QlRoohMTSGxehKf3FzV/rf+Fxi1BhtjrLESDEkhsawGB4jlBJKCaWEUkOpXcl9dKXf01VjWAyPkWOUGDVGV/qbcBvXpd+pLa1T1qnrHNdm3F2+zrzOss66zhYzLQsxRBkxSB2hhBFOZKIQlWhrzFt7RiKQE3JCTsgJOSEn5IQsyIIsyIIsyIIsyIIsyIKsyIqsyIqsyPMw2Igh+4hCVKKtMY/FjEQIoYQRTiAbsiEbsiM7siM7siM7siM7siM7ckbOyBk5I2fkjJyRM3JGzsgFuSCPY5XyiCGXEUY4kYlCVKKtMY5ZRCKEQK7IFXkcuVRHFKISbY159GYkQoghtxE2PiKPcCIThahEi5BxBiMSIYQSRjiRiUJUAnmcQZl/GYasI4RQwggnMlGISrQ1xhmMQBZkQRZkQRZkQRZkQVZkRVZkRVZkRVZkRVZkRTZkQzZkQzZkQzZkQzZkQ3ZkR3ZkR3ZkR3ZkR3ZkR87IGXmcwfF5RMYZFB9hhBOZKEQl2hrjDEYkQgjkglyQC3JBLsgFuSJX5IpckStyRa7IFbkiV+SG3JAbckNuyA15nsHxufHn/nLcP50O6z8lXm/n5y//o7j+984z/Bfj/fL2fHi5XQ7j8918rn/i+x8=", + "bytecode": "H4sIAAAAAAAA/+1dCZgVxRGu2YNld0FAQAFBQUWRc/rtW3grihgIeJHE3HcisOstovE2auKBJ4kYTTTRqIkaERXReMQ78T7xipp44EnURBNNNNGomVq7pV9Pg7Lz16RH7e+bnaXfUFt/1d9/HzPTL6L3yoKIaGn03u98qtVnLpOdOj66O3U1ydHbqavV/7dO26mhdLH/Bpc4W1ERzFZ77HEXY1vFsR0LE596N/h1VsBNXb0Ovl1qBYPYEo8vl9snlNpVi9ohLrXNrLTG5daZ4yuqolorrbNLlZaW9kq5MqFtZtuEuE2VW9pVR2tbS3sHl1jVAWx1aMfqgcmts+LqlnBJGcuRMo4rgrZLkRVbw99uydGg/92YHE3J0ZwcPZKjJ1E18btRujE0eOq6e+oaPXVNnrpmT10PT11PWkESUxqxAYM0QtNwuhGqQXd0NOBsze6Os9XWiLOlmmC22lUzzNYs1QNmq6J6ElaUwKJZ6qnbWQ3WbrknsF2tAcQrEEMlFMMSMoa9gHjJKi7mrH72ANrqDcYMzm+nzgC5rTjHZnaAzEkfClvD2L8+ArjXDBu3ksLdF4zbFLRWNANt9aOwtYKxAvmoOMf9BLjTn8LWCvavvwDutcLGraRwr03F0IomoK0BFLZWMFYgHxXneIAAdwZS2FrB/g0UwD0obNxKCvc6VAytaATaGkxhawVjBfJRcY4HC3BnCIWtFezfEAHc64aNW0nhXo+KoRXdgbaGUthawViBfFSc46EC3BlGYWsF+zdMAPf6YeNWUrg3oGJoRQPQ1oYUtlYwViAfFed4QwHuDKewtYL9Gy6Ae6OwcSsp3BtTMbSiG9DWCMJqhRRm5EMsm1DY+sj5BbZBxbweIdBeRuJ8jH1PqGF1o9yZ95GWfZTv5CkZbSvzix2PUfo82gTHPAzDHzwhHDRQgy5p8qhRhCPiaCqGcCMxj/Fg7qpNm0tjNJfqNH73ISsfx5BxQWAxZaykw2Np5crfVftjCaf644B4pWI4jlYuWF21P46wYoDGPVrjRo0ajF1kvmNgDG1xYbvDqLqgZwebgHkv5edogJ/mScLVEes4W1HIUZ/tr5J02J6bZA26PSUh8r9UQVAMZVEiIhNqx6Jk4mycNirAFUOdQKFfoBgJTHQL0FYZaMuOadmKqcQ8ryRgt4WK0UBKhFLqdlXMN7Fm5fYmVqs+jzcBMQTniiK9ddVKuIYyHpxICYFgvOiFMKSIT8D5lcNi1XsLixMs+yjfyVO6aFu5FXY8zKtsbSY4piHzB9cJBy3jwk3skEdVCEfENpJJJnqxCol501VgXl3bNpc21VzKc7GqAsZiykRJhyfSB6vz6v6diYRruJsB8UrFcDP6YMFa3b+zGWHFAI27TePO2rO7dpH53hwYQ1tc2O6WVF3Q8W0lmc4A3bG2ATB/lBarJkk6PMn6Q1mD/mEWqyRGYSBbhVz42sL201aUydYfNCXkha/JQFtbAm3ZMbXtSsxrOZnoeS3Sx8lUjMa2BaF6kHwX0YC2cltE+5Q+TzEBMY2FP6g4dXyR9MIawZIfq08RrvFMwWHMtYfF+Z3fyu5Uff60CYgh4FRKb+/DF0mTcgrhSDmVcKT8NDC5vj220L0kY59CIZP8o7Vn17TkmJ4cWyXH1smxTXJsmxzbJccMouqGNI3SjWu6p24rT93WnrptPHXbeuq289TNoBUkQZOQycJERO8BNgXo4zRCCU5Hx3Scrdlb4Wy1bY2zpbYh3JBxW5itWWo7mK2KmkFYkUO/YzJDt1vwFKg8A9iuPgPEKxBDJRTDEjKGnwXiJaug70ptB7T1OTBm9DIBYwVyW3GOP0f4vnd7ClvD2L/tBXB/PmzcSgr3F8C4TUFrxbZAW1+ksLWCsQL5qDjHXxTgzpcobK1g/74kgPvLYeNWUri/QsXQim2Atr5KYWsFYwXyUXGOvyrAna9R2FrB/n1NAPfXw8atpHB/g4qhFVsDbX2TwtYKxgrko+Icf1OAO9+isLWC/fuWAO5vh41bSeH+DhVDK7YC2vouha0VjBXIR8U5/q4Ad3agsLWC/dtBAPfMsHErKdyzqBhaMR1oazaFrRWMFchHxTmeLcCddgpbK9i/dgHcHWHjVlK4d6RiaMU0oK2dgHnJ8ymoWpLJFWX0s+L8247Fzvq8iwmIeThiZ0o/MMEXbeE4hX4KqrbrRIpnOa/J7Uw4Uu6CwxgXhJQlt8LjLsy2HYtd9Xk3ExBDwF0pTUq+aEvHqXBIWelw393clXCk3A2YgBxeIi4x9p2Dyk86pkjR2BWIkTyli7ZX+aL07vq8hyGAaWi7U7rx7WE5gSYLJ4IDWP8xJEvWF8R3B/q1B8kOx9BTOZ4qTAPa4yH4Tpa/ILu5DfHm6POe/MNuvHMo3aD5IjPEQw9FOCkdJLCOFIU9NzQEgq8jRTJkrMvmZ2oYPgeIeU9gXoC8Uchc5Dk9AIp7boI2V5/3MgEx4jWX0oLGF0nPWe0gZm0scwnXWPYimeS68cvq594k0xn8PwXWJbBvlwE0D6VGPiB7Jc7zHAs/yG7VTgjfM7+gpyPs+N4C5N+HPvo9mkA+FCd6H0qTSWJnCtTIzbwtxR3GXMJPfTL05qk1gbkk03mgeQBsP1WjjH31eT/jtBlR8AdbOHX7kfwoYx/CkXw/oK39gbbsmO5vxRR1u8ptgCi/99G8kBxZxqtXVtmgkfyJMxayCvq25L5AWwdkwFzxYEZ3KnM0p9EcnAO0heTggUAO5rkH2L5Av21/D5J0+CABuwcDySCF+2ArwCC7Is/dsDgdSPgRJVJAv0/F6DSQvDwEmIs8RQrZwdv+Hirp8KECdg+jsEWKcR9mBRhkV2SEwr0/+5txhCI5VVXImdEPqBiCdxjQ1g8JK3g2XiR2w0nzSArKZ+7kDiF8R4z0MctjKR1OIU/pou1VPpZyuD4fwT/sZYLDaUWvaOqOsJxAE8Y8ltLVALqgDWHqsgUvZVeKMFkfTTmccGJzBJjI6Dv0UzUX0Z3+EThbBd0nsiO3fSKP1OejTECMyBxJ6bvNfFGR9ok8knBkPwqY3Dz2iWTsn+wTKWLbu0/kvOQ4OjmOSY5jk+O45Dg+OU5IjvlE1Q1pHqUb19GeumM8dcd66o7z1B3vqTvBUzefVpAETUImCxMx5H0i5xFu9HQ0ztbsY3C22o7F2VLHwWy1q+NhtmapE2C2Kmo+YUUOvR46X7db8DSsPB/Yrn4ExCsQQyUUwxIyhj8G4iWroJdYTgDaOhGMGb1UwViB3Fac4xMJ3/cuoLA1jP1bIID7pLBxKyncPwHjNgWtFccDbZ1MYWsFYwXyUXGOTxbgzikUtlawf6cI4P5p2LiVFO6fUTG04jigrVMpbK1grEA+Ks7xqQLcOY3C1gr27zQB3D8PG7eSwv0LKoZWHAu0dTqFrRWMFchHxTk+XYA7Z1DYWsH+nSGA+5dh41ZSuM+kYmjFMUBbZ1HYWsFYgXxUZyY2zhLgztkUtlawf2cL4P5V2LiVFO5fUzG04migrXMobK1grEA+Ks7xOQLcOZfC1gr271wB3OeFjVtJ4f4NFUMr5gFtnQ/MS55PQdWQTK4I6Ce/sGbHYqE+X2ACYh6OWEjpByb4ol6OU+inoGoAROKb2QlQtZBwpLwAhzEuICk7txX0uAuzbcdikT5faAJiCLiI0qTki/o4TgVKyna2tYhwpLwQmIA89olk7AsDzY+JKVI0FgExkqcAbHc+nG/n/CJ9vtgQwDS0iyjd+Pii3kJk4URwANH7RBaBLFl6PsZ4EdCvi0l2OIaeyvFUYR7QHg/Bz7f8BdnNbYi3WJ8v4R92411M6QbNF5khHnoowkk5j/BzpAOisOeGhkBo3AdGMmSsA/lphuGLgZgvAeYFyBuFzEWe0wOguOcmaEv0+VITECNeSygtaHyR9JzVDmLWxrKEcI3lUpJJLnqrvMtIpjMIRWCZwHnsEyk18gHZK3GeF1v4QXarNqL4rfkFPR1hxy8TIP/l9NHv0QTyoTjRl1OaTEXYJ5I7jCWEn/qAevPONYElJNN5oHkAbD9Vo4wr9PlK47QZUfAHvZy6K0l+lHE54Uh+JdDWVUBbdkyvsmKKul3lNkCU35drXkiOLOOul1SDRvInzljIKujbklcAbf0OhLkSy+zCtFhzGs3BxUBbSA5eDeRgnluwXQH02/b3GkmHrxGwey2QDFK4r7UCDLIr8twNi9PVhB9RIgX0OipGp4Hk5fXAXOQpUsgO3vb3BkmHbxCweyOFLVKM+0YrwCC7IiMU7v3ZX+AIBT1VVciZ0e+pGIKH5PgfCCt4Nl4kdsNJ80gKymfu5K4nfEeM9BH1WAp4n8gqH/mHnfeb9Plm/mEvE9xE6X0i+aLeQoQxj6UgAhhbhEHvEylFmKyPptxEOLG5GUxk9B36IzUX0Z3+zThbed5tLhViCz1nn8hb9PlWExAjMrdQ+m4zXyS8T2QJuU/kLYQj+61USFIqpN8ed0VIeZs+324CYgh4G6Xnh+gFwVsJR8DbCEfA20kmkWjC3Q6LX0UVc5dfyQ1QK1UN5Q59vtMExDSUOyit3nxRg+NUuLv8VtQdhGs8d1Ix1RtGypIgKUvV6n2XPt9tAmIIeBelSckXNTpOBUvK9ljdRThS3g1MQB7vtzD2OwLNj4kpUjTuAmIkT4HYdoZO9+jzvYYApqHdQ+nGxxd1FyILJ4IDiH6/pQhkyTpsvAfo173A2OfZ8wH9zm04tlSf7zMBMQ1tKaUbH18kPRy7l3DDsaWEI+V9JDscQ9/auVfnEL3sDSN50gsspSI0mLhs5+l+fX7AJM00Dv6g3ql7wEqAVILRy9RSCc76JQT3E64xP0DYxlxD+TwEcD/Qb9vfByUdflDA7kNAMkjhfsgKMMiuyEMA3EjZX2hPjlV3hWz8fySZXgd1X9P4ieT4w8Bc5Cl4SKG2/X1E0uFHBOw+SmELHuN+1AowyK6Y4LG/IQveA8B8/4mKIXhIjv+ZsIJn40ViN5w0C5Uon7mTe5jw0z+kj7jFSrGnnlKLlY/p8+P8w57qPWYFG00OszCJCrwhB3rqKEWOrIuTjxFOWB4XIi26Q34cx79cF1EjXHzlvnjTEYUn9PlJExAjClwh/S21EeEayhOEayhPAhOZx7fUPkErFryl8hNnLOQpINu5f0vtsuR4KjmeTo5nkuPZ5HguOZ5PjuVE1Q1pGaXvRjzlqXvaU/eMp+5ZT91znrrnPXXLaQVJ0CRke0xE9LfURkAflxFuZPMUztbsp3G22p7B2VLPwmy1q+dgtmap52G2Kmo5YUUOfWt/uW634OlQeTmwXf0FiFcghkoohiVkDF8A4iWroJc6ngfaehGMGb1kwFiB3Fac4xcJ3/e+RGFrGPv3kgDuv4aNW0nh/hsYtylorXgOaOtlClsrGCuQj4pz/LIAd16hsLWC/XtFAPffw8atpHD/g4qhFc8Cbb1KYWsFYwXyUXGOXxXgzmsUtlawf68J4P5n2LiVFO5/UTG04hmgrdcpbK1grEA+Ks7x6wLceYPC1gr27w0B3P8OG7eSwv0fKoZWPA209SaFrRWMFchHxTl+U4A7b1HYWsH+vSWA+79h41ZSuN+mYmjFU0Bb71DYWsFYgXxUnON3BLjzLoWtFezfuwK42WDAuJUU7igqhlYsA9qqwWHO5WvROOnLgPY45zXWQ+4gu7m9ilqrfa9zH7jgD9w6vsi8iopulMu0UXSjPDFwMTIEQuNeICRGyK9F44cYaiMc5jqgGAF5o5C5+OTderdUC1q9DkI3V7zqPYLWLSrWu/X1wMbSTUgg0N8M1RDJdAbhCGwll69Fkxr5gOyVOM+1AiMpO6bdV/YIaZytlNjxTgBg8jd+DHo0gXwoTnSjh0xF+Fo07jBY6NFTH+QeE/VCnQeaB8D2UzXKaNKONrsjiiY9orDrmnMYZTQCe7ZmoK0eQFt2THtYMUWtj7gNEOU356Ypkh1ZxlmK06CR/IkzFrIKeh2sCYi5J3A0SITvVHiAUi/AwVrgoALJwTXAU253dG4KusNqAvpt+9srEnS4V4S32xtIBincvYUWftGzExanNQRGlEgB7VOQTgPJyzXBN0/yEqlmIZHqGwk63FdApPoFLlKMu19OIpV1hMK9f3OE3yAIOFVVyJlR/4IIHpLja4EFz8aLxC61QRB3cmsKdMQf9w2C1tZiNMBdjlk7Sn8tGl/UXYgw6E2DDGE+LpsGrQ0UmwERlsioDs/e+2SAwKBkQITKR/tqbUKEWN6DxEDl9w1UA3UQBrnCM9AjPIOiD96YCBnErI1xILAxDopwCSjmzliV3Ei5jg7CYJeU60TpRyAGR8XaLWsdICkHAxdt8yTloKh4pByig7CuS8AhHlKumwMpB0U4Ug4BknLdQO8kGP+4AQ4RWFPIrwFVcL1RnN9QYz0dhKFuY1kvSt9yHiregKqDmLUBrQdsQEOjIpIyVkMLSMphOgjru6QcFqWXotEKPhRIwGFAAq4vlEg04daHxa+ifP5ljeNIem9fRvRq2UigjxsIi43E0HEDoTsCboHYdgRnQ+37cFdw+IPXnbrhkdj3Fr4fSOwKYqw2BArR8ILcYkBi3qgKczZrNpc20vxanfusyLggsJiycSTo8Mbe+xvZLG8MvG80Akg2qRiO8C4LZ7M8AiwGaNzDV4I7q91NgLhtQWC77jdSS9wiQPme51RGquMhpJ/OyGKkDsIod2QxMoepzHDgVGYkUOBGFWQqMwoXvxZfD4+egvANxWlAezsmNnay/AXZrRo1jP6gRpCVbGOAvfxMoK1Zwj1nnK0oTswYz5xO4mUnU9AYgLZEhQbI0areZ6x2dJzb+4zVf9CuG2c5YQq6RxoD7EXGAW3FQFt2TG276GEcx3JsJLCZCcnkKM5YJGI4VbcFdIMeW9C7BReTjGAS0M9KXC1ySgeh5IqcitL3gPmiXo5TaJGzg5hl2JgAVQooTKWcV5WzPvZ4sc4hWuBAJFedP4owJ03ajJ2nFp2osts4+IMeTh1fVCucYPRzqFIJzvpVVC3AxlwGN+YPu/ocZyuqBbxwZkprJOhwq8AQYbzwinGcrXTiHu+Z/8UZi8/XrELCjbQlgvbkaHVXyMY/QajXQd+CQ3K8AsxFnoJXFhK8tkjQ4TYBwds0cMFj3JsWSPDKgQteGZjviQURPCTHNwMLno0Xid1wclFiYyGu3Sju5CoC0z+kj4tAtjh+5CkA253t2s775lqMJrnTv82tYKPJwUFHBSu2yIGeOkqRI0v82NbmQGGZFMmQFt0hT4pQ8RvfuTZouFLn+FxD1V9HT57r2vR5rRdO7zvxpDm329dtv4rPTtFBmfL2Y9MXLzhqhP3ZBZH//xlfzEOG5nmQJstnvmay/necrZSM/WYZ+7G7S52Nxf67phjtqfP8v2gl/3Z1a1XXrmrU39PzmbHZV59tfw2OPvpsYllv2UXG0tjvJmNfGfsNMvZbfFyw60zc3CVH+3fjU6MTc7CvO0Qe/2qdv+n6aF/j4697E8cdmNV+iGt9/DWf9aa0f+7/a/T4atcZbvnagpsXo1H1K7HVYH1uX9/gXCuVw74en6KV/O3+Mj6836b6ydj36mt/6/d+Dk6bV5NBPhh7hgP1lC41zmcr6+civH/K9cWnL6YYzvSz6kw8/weLpuXU6p0BAA==", + "debug_symbols": "pdjNbhNJFEDhd/E6i76/VTWvMhohAwZFspLIJEgjxLtPV98+EBazaW98T2Luh7C7bOwfp8+Xj29fPzw+fXn+dvrr7x+nj7fH6/Xx64fr86fz6+Pz0/rbHz8fTvz44fV2uay/Or27f916Od8uT6+nv57erteH0/fz9W37Q99ezk/bfD3f1nuXh9Pl6fM6V/DL4/Uy6+fD7+3l/1dlsX1Z5Pd6HNpvR/ZN2Ld+3777kf3R931d7twXObCvGuzbvftHHn8dbd+3Q/9+HfJrP+7bP3T9mTr7h66fd/tuB/Z94fF30SP7xt/vfuT59/i1n8ud+0ceP+/Kfr9zfxy5/mLh/IXcua9HHr/49foTduT6CU/2Q+/bP/T8R+P5j37vfh7Yz4XHLyXu2z/0/KXx/Oeh94/3++OP/X/Wn86fHm9/vOOffH3LeDjFdpvbbdtu+3Y7tltZakgNrWE1CpASpAgpQwqRUrQULUVL0VK0FC1FS9FStBQtxUqxUqwUK8VKsVKsFCvFSrFSvBQvxUvxUrwUL8VL8VK8FC8lSolSopQoJfYHtpQoJUqJVVlfZWJV1v+s5FJDamgNq+E1osaqrFd3rsr6Ip+9xthGW2pIDa1hNbxG1MgapbRSWim9lF5KX5X1NPdVWd+Uu9eIGlmj1eg1xjbGqqxX4ViVsQ6tYTW8xnxc1st45D7bPvs+R01ZFkIIJYxwIogkGtEJZEEWZEEWZEEWZEEWZEEWZEVWZEVWZEVWZEVWZEVWZEM2ZEM2ZEM2ZEM2ZEM2ZEd2ZEd2ZEd2ZEd2ZEd25EAO5EAO5EAO5EAO5EAO5ERO5ERO5ERO5ERO5ERO5IbckBtyQ27IDbkhN+SG3JA7ckfuyB15njTZXj+nrDOSaEQnxh7z1FUIoYQRTiAP5IE8kMcu67IQQihhhBNBJNGITiALsiALsiALsiALsiALsiArsiIrsiIrsiIrsiIrsiIbsiEbsiEbsiEbsiEbsiE7siM7siM7siM7siM7siMHciAHciAHciAHciAHciAnciInciInciInciInciI35IbckBvydgZtxpRzRhKN6MTYYzuDWwgx5TZjyn2GE0Ek0YhOjD22M7iFEEogD+SBPJAH8kAeu2zLQgihhBFOBJFEIzqBLMiCLMiCLMiCvJ3BMaPNrypmdGLsMc9ghRBKGOFEEEkgK7IiG7IhG7IhG7IhG7IhG7IhO7IjO7IjO7IjO7IjO7IjB3IgB3IgB3IgB3IgB3IgJ3IiJ3IiJ3IiJ3IiJ3IiN+SG3JAbckNuyA25ITfkhtyRO3JH7sgduSN35I7ckTvyQB7IA3meQd0+BUxZZwSRRCM6MSp8nsEKIZQwwokgkpiyzejE2GOewQohlDBiyj5jyjEjiUZ0YuyxncEthFDCCCeQFVmRFVmRDXk7gzljym2GEU4EkUQjOjH22M7gFlPuM6Y8ZhjhRBBJNKITY4/tDG4hBHIgB3IgB3IgB3IgJ3IiJ/L2WW5+F/D9fHs8f7xevtVX7V/enj69++b99d8X7uG7+Zfb86fL57fbZX5m3+5bP8X/Bw==", "file_map": { "50": { - "source": "fn main(x: u64, y: u8, z: i16) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n}\n", + "source": "fn main(x: u64, y: u8, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176\n assert(u >> (x as u8) == 0);\n assert(z >> (x as u8) == 0);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_0.snap index 2732d140050..fc0594deb0a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_0.snap @@ -33,6 +33,15 @@ expression: artifact "width": 16 }, "visibility": "private" + }, + { + "name": "u", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" } ], "return_type": null, @@ -47,11 +56,11 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/+1da5cU1RXd82IYwIgBH4kmajRRRE3dnh7okSgoKqKgaNREERGG7qjxER/4AkEI70fiM9FEEk00EWOQIPL0mcCHfMkvyMr3/IF8y1rpA/fAneoaEGqfWreCd62aO1QXZ84+Z599b92+Xd2Gg21/8xjXdvB36Tp8L21K6pwcw1Pn2pvH6ObR6f9PO1pbaE9akq+5NpqtepLhLse2S5IwFh2+70wHOgyu/t7pA40MA1MowAcHsTeZUK3WJ1bqrtfNSyr982t9SbVv/oSaq7m+Wt+CSq23t16r1ib2z++fmPS7am/dNfr6e+sNaYnrINhqeMc6icntDOKabvGSMrEjZZLUDG1X2oLYKn+7msew5tHtz/U0jxHNY2TzGAUMJn4XWothWMa57oxzwzPO9WScG5FxbmTGuVE4TBJtPdyAUYpQC6cLrIJuNIbxbC3o5tnqH86z5XpotupuBM3WgBtJs1Vzo8AVJbJoVkb5Omvn2q2OItbVSUS8BjF0RjGsMGP4FSJeBC2NOa+fI4m2TiZjJuf3gM4Que0kxydn8DtvHEcjbg0T/0Yb4D4lbtzOCvdXybi1sbViBNHWGMStFYKVyEcnOR5jwJ2xiFsrxL+xBrhPjRu3s8J9GsqhFT1EW6cjbq0QrEQ+Osnx6QbcOQNxa4X4d4YB7q/FjdtZ4f46yqEVw4m2zkTcWiFYiXx0kuMzDbhzFuLWCvHvLAPc34gbt7PC/U2UQyu6ibbORtxaIViJfHSS47MNuHMO4tYK8e8cA9znxo3bWeH+FsqhFcOIts5D3FohWIl8dJLj8wy4cz7i1grx73wD3N+OG7ezwv0dlEMruoi2LgBXK6wwMzexXIi49VHyS6xBJ7y+wKBexvF8TLJ2qHF1o3og7+MC+yzfkdFy2nb6SxiPi3w/XoOjm2HkhX8ZB41U0BVPHncReEQcj3IINxPzxRmYj9dmyKWLPZc6Pf70JqssjjHjwsCi7RJLhy/B0Mp/vPYvAU/1LyXitYrhpRhasI7X/qXgigEb93iPmzVrULvMfH+XGMNQXMTuuRjc2HcHF5J5b+XneIKfupPwWMQ6ydccc9YX+ptYOhxmMm/Qw73wQPaHKkDFUDUlIjOhYSz0fvDQvkpVATlxTipQ7A9QjCMmukK01Uu0Fca0N4ipxX2eM7BbQTkKxIGl1HVXzk9iDRT2Sayq7/s0IEpwOVGmT11VwSuUPnIiLQRC8LIXwpgiPoHnVwGLVQcXFicE9lm+I6Mdp22XPhHGY6LvaxocLWR54RPjoOVcuElS5HETwSNiDTbJZC9WMTH3HwHzsdoOudTvuVTkYtVEMhZtl1k6fBmOrs7H+ncuA69wJxHxWsVwEo4uWMf6dyaBKwZs3DWPO+/InrbLzPf3iDEMxUXsXonBjR3fKmwGA/bAWiNg/n9arLrc0uHLgz+UN+hfZLHKYhZGslXKha8rfD9ZnVZFmRz8QW0xL3xNJtqaQrQVxjS0a3FfK8lk39cyfZyMchTbFWCNIMUuohFtFbaIprOWqzQgWizyQi11Ti6yXlgDLfmJuxK84rmKh7HIEbbC9DvDXRNSTvX91RoQJeBUtD7eRy4yJuWgIOYl5VTwSHk1SklKx/Q7w10TUl7j+2s1IErAa9B6g8JWxavBI+A14BHwWpRjSnEtLX61QqcUpVDvpDaoUKb5/joNiBbKNLSqt1zUnXKKXTw89a65aeAVz3Uop3rTSFkxJGVlsHpP9/31GhAl4HS0klIu6kk5FS0p64mbDh4prycmoIA3PyuCfVqk+dGYMkVjOhEjMhrFdmrqdIPvZygBtNBuQGvxyUXDjcgiiZAAdp2AZMk7bbyB6NcMYuyLHPmIfhc2HZvp+xs1IFpoM9FafHKR9XRsBnjTsZngkfJG2E7HWEvO+mzfGT6H7CVnGsmbo8BMlKFgkmqYp5t8P0uTpsUhL3Slzs0KEmCV4M6SJDjvA6ZvAq+YZ4FbzEW9C30T0e/Q35stHb7ZwO4tRDJY4b4lCDDJLnVrjgqJFKn4Sx3JuerumMX/fdiMOu2kvKifTI7fSsxFkYLHFOrQ39ssHb7NwO7tiFvwBPftQYBJds0ET/yNWfBmEfP9A5RD8Jgc/yG4ghfiZWJXTupCJctnGeRuBf/2j+kjb7Gy0UBGo9hOLVbe4fs75Ud4q3dHEGw2OXRhkhV4JQf71tGKHHkXJ+8AT1juNCIte0C+k8e/kn7WtGH3JWgpUZjt+7s0ICoKcqJMnzWdDV6h3EVMpOWCqfor2LOeT5Xka8TN4bVkNs+vwt5hmOP7uzVpWhxz0PoOg1zUbZRgSYQEkD3qWSU477sfc4ixu5sXr+TLt+TSbXDBzPX9PRoQLY65aC0YuahMb8nNBY+U94CbXIuPBc3OyAdDyFj5YI7484gFkbXIyF5v0BGflO+K4J+DE2cGEeZmvlWStIhYSZIEzYPtx+WSXI0zC9D4DSBukRTiDOBwY+Euao/FXMS9x2IuuPkfKpZJvuaYPA1zvsD3dXVaZ07yQnfqXB32s6kB8EheJ9pqEG2FMW0EMWUvjGoBsvwe8LywnEEneVqqoJn8SXI2BI09CVhAtPUj8AZqgD+ozPGcZnNwDtEWk4P3EjlY5NaEBUS/Q3/vs3T4PgO79xPJYIX7/iDAJLsm38Qj4nQv+DNKpoD+GOUYNJi8fICYiyJFijnAh/4+aOnwgwZ2H0LcIiW4HwoCTLJrMkOR0V/8Ze+fIt6qOuad0cMoh+AxOf4TcAUvxMvEbrV/Sga5B/Dl/qnctlNbJR7x/aPyI1wmeATl2T+l5DhR9k89Ap6wPGpEWvaA/Cgtfsf2mDHG0hslBq64h+c85vvHNSAqCo/h8FRZz8lFR9tTxQxi3uJ5jOjX48QElHNTX60wUi70/RMaECXgQrRuw5CLyrTRbyF4pHyCmNwiSUkrpgJJ+aTvn9KAKAGfRCsp5SJrUj4OHimfBI+UT5GTyx6mFwbJJOajwAKq8UajpLipxtO+f0YDosUiL6TfDpaLbAtocBDzFtDT4BH0GZSRlIlj+p3hrgkpF/l+sQZECbgI9g+PfAY8Ai4Cj4CLYZNINuEW0+JXc1n+sTbQsVeymM+Hfxa2YmMxdXw2sM/yHRmNYjslOEt8v1SDo4IjL/wndU4uMnrk2qFAclf8ErcEPHIuhU2C2cv/TMzPDcKcz1rIpec8v4r8nq0lZCzallk6vAxZip3P8jLwCnc5Ea9VDJcjS7DyWV4OrhiwcS8dAndeuz8l4g4FQeymH6Zr8clOlu9F3spYDTxg+pmaWazw/UoNiCZ6BexvZZaCN4NYAR4BV8ImkWzCreTFr7czyH+6sf2+CiUolIPfgWhlu9IWxFZn66uax+rmsaZ5rG0e65rH+uaxoXlsBAYX6Cq0riCvzji3JuPc2oxz6zLOrc84tyHj3Ea0ikUPN2DUpzKvAqtwGo3VPFsL1vBs9a/l2XLraLbqbj3N1oDbQLNVcxthO1NM8rXKRl9n5HWh6kZiXf2MiNcghs4ohhVmDH9OxIugsZcvNhBtPU/GzF47FaxEbjvJ8fPg3zm9gLg1TPx7wQD3i3Hjdla4XyLj1sbWivVEWy8jbq0QrEQ+OsnxywbceQVxa4X494oB7l/EjdtZ4f4lyqEV64i2XkXcWiFYiXx0kuNXDbjzGuLWCvHvNQPcv4obt7PC/WuUQyvWEm29jri1QrAS+egkx68bcGcT4tYK8W+TAe7fxI3bWeH+LcqhFWuItt5A3FohWIl8dJLjNwy48ybi1grx700D3L+LG7ezwv17lEMrVhNtvYW4tUKwEvnoJMdvGXDnbcStFeLf2wa4/xA3bmeF+48oh1asItp6h5iXUn6HfDJQ2M6nzb5/VwOimxk2o3WDg1xk/dE8xgYH3Q21GTxSvmuUXHYhMjH/CXEP2iI6xIHBidi+A76Iv8fzMfNhgWwhk7y/R7DbSLXNxDiE+P9sHYi8xD1SIPKSawsxqBYxlORsCZLFwl3kyE60ZboVlsmFMK7v+36rOq0zgq3BH9TGnhFsIZJmK9HWX4i2wpiGdtkj0RafTPZIzPRxK8pRbO+DO6oDxYhZu1F8QfSzlgwWoG2+/0ADosWyDa23KXLRySmn2KIUBjHPbUoTqNsGXvF8gBOalBX5keEuzXYYi+2+/1ADogTcjlZSykWnpJyKlJR1sbUdPFJ+SExAAR+Urwj2bZHmR2PKFI3t4M4E0o1g28mPMOc7fL9TCaCFtgOtxScXjTYiiyRCAth1ApIlz8gnGHcQ/dpJjH2RIx/R78KmY7t8v1sDooW2C63FJxdZT8d2gjcd2wUeKXfDdjrGuj/Uj/Ht9Dlk3x+SSH5gFNiF+Aum2Wphnvb4fq8mTYtDXhiVOrcXhwvEKsHsh0BbJTjv5z/3gFfMe8Et5vQyPobIeZKvuT1Ev0N/P7J0+CMDux8TyWCF++MgwCS7Jl+nIUUq/hJHcra6O2bxfwKbUaedlBf1k8nxT4m5KFLwmEId+vuZpcOfGdj9HHELnuD+PAgwya6Z4IUzM4KvdMHbS8z3X1EOwWNy/G/gCl6Il4ldOakLlSyfZZD7FPzbP6aPrMVKiR8yGsF2y2LlPt/vlx/hrd4+2H1/kC5MMoKVBORg3zpakSPv4uQ+8IRlvxFp2QPyflr8Jhx4tpdypSPlc9bCamfwuz507LR/bxoz6aWH/x5eN+sIr+32/dT//nPa1hdXXRi+9o8h/p/6pjtb9ZFdIwJ/O8B7w0Dtj7Sxn6S/Cj7EEv5dbZqLzoz/1zbEv9OadaRrjzTjPynjNbU5Bgdb6K/i0HdSNZb65gs7lmp/mI19p/a7bez3ZnEhPKdxSy83hr+rTz2pmJN9ndeW4V9H6m+mfQyvyeJvWmfSk7KOL3BtFn/1tdEZ/qX/X0+Gr+E55VZWLaTzohrVNYSt7uD18Pru1LVWORyT4VPbEH/7VBsfDtXUWBv7mfp6avD72BTOkFdTSD6oPeVAF1pbe+q1oca5Nr5/LbsAsvRFm3JmbHBO4/k/JvvNFwoGAQA=", - "debug_symbols": "pdjLThtJFIDhd/GaRde51CWvMhohAyayZBnk2JFGKO8+VXX6J2SRTXvj84M5n0S7y1h87F4OT7fvj8fz69uP3bd/PnZPl+PpdPz+eHp73l+Pb+f+3Y9fDzu+fLxeDof+rd2X5/vW+/5yOF9338630+lh93N/us0f+vG+P8953V/6s8vD7nB+6bODr8fTYdSvh9/by99Xm6+7aZHPbd+y3jasJ1H2dblzP2/Zb1y61O7bl0U37Esq7Mu9+1uuv7TEfqsb9lX4/VXKln373Ld8377blv1c2S937tct9682W/dtuXd/y/Wzz/vH0pb7x1TY13rf/qbX3zKvv+U798uWtz9rvP/4ptfPavncT3fub/n9Xbh/fNP779d9/2P/3/7V/vl4+ePv3U77W+bDzuajz8c8H8t8rPOxzce0xEgxJEbspwBSCCmIFEYKJIUioUgoEoqEIqFIKBKKhCKhSCgaioaioWgoGoqGoqFoKBqKhmKhWCgWiq1XJBQLxUKxUCwUC8VD8VA8FA/F1wsbiofiXemHzLvS71Vvc+QlRoohMTSGxehKf3FzV/rf+Fxi1BhtjrLESDEkhsawGB4jlBJKCaWEUkOpXcl9dKXf01VjWAyPkWOUGDVGV/qbcBvXpd+pLa1T1qnrHNdm3F2+zrzOss66zhYzLQsxRBkxSB2hhBFOZKIQlWhrzFt7RiKQE3JCTsgJOSEn5IQsyIIsyIIsyIIsyIIsyIKsyIqsyIqsyPMw2Igh+4hCVKKtMY/FjEQIoYQRTiAbsiEbsiM7siM7siM7siM7siM7ckbOyBk5I2fkjJyRM3JGzsgFuSCPY5XyiCGXEUY4kYlCVKKtMY5ZRCKEQK7IFXkcuVRHFKISbY159GYkQoghtxE2PiKPcCIThahEi5BxBiMSIYQSRjiRiUJUAnmcQZl/GYasI4RQwggnMlGISrQ1xhmMQBZkQRZkQRZkQRZkQVZkRVZkRVZkRVZkRVZkRTZkQzZkQzZkQzZkQzZkQ3ZkR3ZkR3ZkR3ZkR3ZkR87IGXmcwfF5RMYZFB9hhBOZKEQl2hrjDEYkQgjkglyQC3JBLsgFuSJX5IpckStyRa7IFbkiV+SG3JAbckNuyA15nsHxufHn/nLcP50O6z8lXm/n5y//o7j+984z/Bfj/fL2fHi5XQ7j8918rn/i+x8=", + "bytecode": "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", + "debug_symbols": "pdjNbhNJFEDhd/E6i76/VTWvMhohAwZFspLIJEgjxLtPV98+EBazaW98T2Luh7C7bOwfp8+Xj29fPzw+fXn+dvrr7x+nj7fH6/Xx64fr86fz6+Pz0/rbHz8fTvz44fV2uay/Or27f916Od8uT6+nv57erteH0/fz9W37Q99ezk/bfD3f1nuXh9Pl6fM6V/DL4/Uy6+fD7+3l/1dlsX1Z5Pd6HNpvR/ZN2Ld+3777kf3R931d7twXObCvGuzbvftHHn8dbd+3Q/9+HfJrP+7bP3T9mTr7h66fd/tuB/Z94fF30SP7xt/vfuT59/i1n8ud+0ceP+/Kfr9zfxy5/mLh/IXcua9HHr/49foTduT6CU/2Q+/bP/T8R+P5j37vfh7Yz4XHLyXu2z/0/KXx/Oeh94/3++OP/X/Wn86fHm9/vOOffH3LeDjFdpvbbdtu+3Y7tltZakgNrWE1CpASpAgpQwqRUrQULUVL0VK0FC1FS9FStBQtxUqxUqwUK8VKsVKsFCvFSrFSvBQvxUvxUrwUL8VL8VK8FC8lSolSopQoJfYHtpQoJUqJVVlfZWJV1v+s5FJDamgNq+E1osaqrFd3rsr6Ip+9xthGW2pIDa1hNbxG1MgapbRSWim9lF5KX5X1NPdVWd+Uu9eIGlmj1eg1xjbGqqxX4ViVsQ6tYTW8xnxc1st45D7bPvs+R01ZFkIIJYxwIogkGtEJZEEWZEEWZEEWZEEWZEEWZEVWZEVWZEVWZEVWZEVWZEM2ZEM2ZEM2ZEM2ZEM2ZEd2ZEd2ZEd2ZEd2ZEd25EAO5EAO5EAO5EAO5EAO5ERO5ERO5ERO5ERO5ERO5IbckBtyQ27IDbkhN+SG3JA7ckfuyB15njTZXj+nrDOSaEQnxh7z1FUIoYQRTiAP5IE8kMcu67IQQihhhBNBJNGITiALsiALsiALsiALsiALsiArsiIrsiIrsiIrsiIrsiIbsiEbsiEbsiEbsiEbsiE7siM7siM7siM7siM7siMHciAHciAHciAHciAHciAnciInciInciInciInciI35IbckBvydgZtxpRzRhKN6MTYYzuDWwgx5TZjyn2GE0Ek0YhOjD22M7iFEEogD+SBPJAH8kAeu2zLQgihhBFOBJFEIzqBLMiCLMiCLMiCvJ3BMaPNrypmdGLsMc9ghRBKGOFEEEkgK7IiG7IhG7IhG7IhG7IhG7IhO7IjO7IjO7IjO7IjO7IjB3IgB3IgB3IgB3IgB3IgJ3IiJ3IiJ3IiJ3IiJ3IiN+SG3JAbckNuyA25ITfkhtyRO3JH7sgduSN35I7ckTvyQB7IA3meQd0+BUxZZwSRRCM6MSp8nsEKIZQwwokgkpiyzejE2GOewQohlDBiyj5jyjEjiUZ0YuyxncEthFDCCCeQFVmRFVmRDXk7gzljym2GEU4EkUQjOjH22M7gFlPuM6Y8ZhjhRBBJNKITY4/tDG4hBHIgB3IgB3IgB3IgJ3IiJ/L2WW5+F/D9fHs8f7xevtVX7V/enj69++b99d8X7uG7+Zfb86fL57fbZX5m3+5bP8X/Bw==", "file_map": { "50": { - "source": "fn main(x: u64, y: u8, z: i16) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n}\n", + "source": "fn main(x: u64, y: u8, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176\n assert(u >> (x as u8) == 0);\n assert(z >> (x as u8) == 0);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 2732d140050..fc0594deb0a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -33,6 +33,15 @@ expression: artifact "width": 16 }, "visibility": "private" + }, + { + "name": "u", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" } ], "return_type": null, @@ -47,11 +56,11 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pdjLThtJFIDhd/GaRde51CWvMhohAyayZBnk2JFGKO8+VXX6J2SRTXvj84M5n0S7y1h87F4OT7fvj8fz69uP3bd/PnZPl+PpdPz+eHp73l+Pb+f+3Y9fDzu+fLxeDof+rd2X5/vW+/5yOF9338630+lh93N/us0f+vG+P8953V/6s8vD7nB+6bODr8fTYdSvh9/by99Xm6+7aZHPbd+y3jasJ1H2dblzP2/Zb1y61O7bl0U37Esq7Mu9+1uuv7TEfqsb9lX4/VXKln373Ld8377blv1c2S937tct9682W/dtuXd/y/Wzz/vH0pb7x1TY13rf/qbX3zKvv+U798uWtz9rvP/4ptfPavncT3fub/n9Xbh/fNP779d9/2P/3/7V/vl4+ePv3U77W+bDzuajz8c8H8t8rPOxzce0xEgxJEbspwBSCCmIFEYKJIUioUgoEoqEIqFIKBKKhCKhSCgaioaioWgoGoqGoqFoKBqKhmKhWCgWiq1XJBQLxUKxUCwUC8VD8VA8FA/F1wsbiofiXemHzLvS71Vvc+QlRoohMTSGxehKf3FzV/rf+Fxi1BhtjrLESDEkhsawGB4jlBJKCaWEUkOpXcl9dKXf01VjWAyPkWOUGDVGV/qbcBvXpd+pLa1T1qnrHNdm3F2+zrzOss66zhYzLQsxRBkxSB2hhBFOZKIQlWhrzFt7RiKQE3JCTsgJOSEn5IQsyIIsyIIsyIIsyIIsyIKsyIqsyIqsyPMw2Igh+4hCVKKtMY/FjEQIoYQRTiAbsiEbsiM7siM7siM7siM7siM7ckbOyBk5I2fkjJyRM3JGzsgFuSCPY5XyiCGXEUY4kYlCVKKtMY5ZRCKEQK7IFXkcuVRHFKISbY159GYkQoghtxE2PiKPcCIThahEi5BxBiMSIYQSRjiRiUJUAnmcQZl/GYasI4RQwggnMlGISrQ1xhmMQBZkQRZkQRZkQRZkQVZkRVZkRVZkRVZkRVZkRTZkQzZkQzZkQzZkQzZkQ3ZkR3ZkR3ZkR3ZkR3ZkR87IGXmcwfF5RMYZFB9hhBOZKEQl2hrjDEYkQgjkglyQC3JBLsgFuSJX5IpckStyRa7IFbkiV+SG3JAbckNuyA15nsHxufHn/nLcP50O6z8lXm/n5y//o7j+984z/Bfj/fL2fHi5XQ7j8918rn/i+x8=", + "bytecode": "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", + "debug_symbols": "pdjNbhNJFEDhd/E6i76/VTWvMhohAwZFspLIJEgjxLtPV98+EBazaW98T2Luh7C7bOwfp8+Xj29fPzw+fXn+dvrr7x+nj7fH6/Xx64fr86fz6+Pz0/rbHz8fTvz44fV2uay/Or27f916Od8uT6+nv57erteH0/fz9W37Q99ezk/bfD3f1nuXh9Pl6fM6V/DL4/Uy6+fD7+3l/1dlsX1Z5Pd6HNpvR/ZN2Ld+3777kf3R931d7twXObCvGuzbvftHHn8dbd+3Q/9+HfJrP+7bP3T9mTr7h66fd/tuB/Z94fF30SP7xt/vfuT59/i1n8ud+0ceP+/Kfr9zfxy5/mLh/IXcua9HHr/49foTduT6CU/2Q+/bP/T8R+P5j37vfh7Yz4XHLyXu2z/0/KXx/Oeh94/3++OP/X/Wn86fHm9/vOOffH3LeDjFdpvbbdtu+3Y7tltZakgNrWE1CpASpAgpQwqRUrQULUVL0VK0FC1FS9FStBQtxUqxUqwUK8VKsVKsFCvFSrFSvBQvxUvxUrwUL8VL8VK8FC8lSolSopQoJfYHtpQoJUqJVVlfZWJV1v+s5FJDamgNq+E1osaqrFd3rsr6Ip+9xthGW2pIDa1hNbxG1MgapbRSWim9lF5KX5X1NPdVWd+Uu9eIGlmj1eg1xjbGqqxX4ViVsQ6tYTW8xnxc1st45D7bPvs+R01ZFkIIJYxwIogkGtEJZEEWZEEWZEEWZEEWZEEWZEVWZEVWZEVWZEVWZEVWZEM2ZEM2ZEM2ZEM2ZEM2ZEd2ZEd2ZEd2ZEd2ZEd25EAO5EAO5EAO5EAO5EAO5ERO5ERO5ERO5ERO5ERO5IbckBtyQ27IDbkhN+SG3JA7ckfuyB15njTZXj+nrDOSaEQnxh7z1FUIoYQRTiAP5IE8kMcu67IQQihhhBNBJNGITiALsiALsiALsiALsiALsiArsiIrsiIrsiIrsiIrsiIbsiEbsiEbsiEbsiEbsiE7siM7siM7siM7siM7siMHciAHciAHciAHciAHciAnciInciInciInciInciI35IbckBvydgZtxpRzRhKN6MTYYzuDWwgx5TZjyn2GE0Ek0YhOjD22M7iFEEogD+SBPJAH8kAeu2zLQgihhBFOBJFEIzqBLMiCLMiCLMiCvJ3BMaPNrypmdGLsMc9ghRBKGOFEEEkgK7IiG7IhG7IhG7IhG7IhG7IhO7IjO7IjO7IjO7IjO7IjB3IgB3IgB3IgB3IgB3IgJ3IiJ3IiJ3IiJ3IiJ3IiN+SG3JAbckNuyA25ITfkhtyRO3JH7sgduSN35I7ckTvyQB7IA3meQd0+BUxZZwSRRCM6MSp8nsEKIZQwwokgkpiyzejE2GOewQohlDBiyj5jyjEjiUZ0YuyxncEthFDCCCeQFVmRFVmRDXk7gzljym2GEU4EkUQjOjH22M7gFlPuM6Y8ZhjhRBBJNKITY4/tDG4hBHIgB3IgB3IgB3IgJ3IiJ/L2WW5+F/D9fHs8f7xevtVX7V/enj69++b99d8X7uG7+Zfb86fL57fbZX5m3+5bP8X/Bw==", "file_map": { "50": { - "source": "fn main(x: u64, y: u8, z: i16) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n}\n", + "source": "fn main(x: u64, y: u8, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176\n assert(u >> (x as u8) == 0);\n assert(z >> (x as u8) == 0);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 1d270b9ca2f..a8a8e8daa56 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -33,6 +33,15 @@ expression: artifact "width": 16 }, "visibility": "private" + }, + { + "name": "u", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" } ], "return_type": null, @@ -51,11 +60,11 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/+1bPW8jVRR98+F47MHxJllgRUNFQ8P4Y2O7MxJJQ0WHEI0T7xQIIRoKGpSCDiEqhCgQQjT8ADoaKjoaGio6hKgQokAIbbE7yruek+P7Jt7Ne1nvakeKZjw+797zzr33zfXMJDLnW3z/L7LHqd0nZn0TzNzui6ttA4+2ipA8o8eEZxyI54VkiGzCuDaZ1K496NjPMXyfeJx0h/z6tD8txpOOMj+P/EcdazMNbL8Vxn7RtnZeO6vt41zEb0I4bYxgjgBzBJgIMMeAOQZMlWc9wLOvnlnP4SP6DvNdbGf3//ZMfbxvjzvkK0T+IV/f8TtQ+Iuv3M41ji7ONUyujgvhITnTtfbZZ0za78B3/hbr4YqP5HgLfGA8dhr4GONvrWsRnxfsvopRRjFqB4nRdKVJZu2lECNcY1gzwb9IWnWC8CyKfbBrFF/INzeb5VmYvF/PM5emKWkq+JeIZxaEp65pRpoKx649dq0t2nXJX+2ON67dlkPTl+1eqy2OydwL56maB6lxX1OZ8yuk7TbkQW4ePA/8aTq8sqa3t0DTprUJ+yJe9yMHRlunsQfj81yjmhb+avf8B5f4qbYu+Ggr+vQUPjJWu87441rXbNfaw1zX+LQI/yrxzGFM6PzKyXegeA7F/jNB7E/KiOaDaz365GuB4I/tvurb3iNNemE0GYj93cCa9wPxl3XiBtjntVE47NF5TxxWtbcPcU0Un8IxJjwey3g89wZp1yc7rC/Hcg9sJ8o5WcOrvHudxnYBp619kpei8XOEndvPxZW2urb2SCP22SU+zwfhU8f8Ftlnn13iK/zfBM3fssdy/cC8uAW4txtwXQV3XTE5MM0x6W9ZTPrEV/ifgIZL0vqm0WNSNuD6Co7rKoFzGM+bhH8WNJTzuLZwDAT/DnB4F2yEy4tirRfBOGi12oTHcz2Yy/uOsblp7tFwbNh+Y1BwP5A65iX+uR/4gHhiDxC6J+N1PQ+iUb2G8DrJPrlnEvyHdl/F9ZsGvTzm9xPZM/F93ce9Z/qYtAvZM31EYzPAaWvRtvVMGfF51NdnXg+F/yeg+af2+LKe6bMGXKbgnvZMD9YzfQ4afkFau3qmLxtwfQXHdRW6Z/oKOHwNNsLlRbH2PAPjoNVqEx7PYc/0rWOsq2eKlbHacx1/Ogw3vo/l6ge+I56PsmcKo1FzrvB9VGPqOsP7tlxL2jixGbZPXr936XpGIv5jsx5b7T6FZk/7TcDfxYpd9ofjUS/tOs/PHr+3++pzbhMocM5MmDPey9b49zbQC+ev6dtxzP8Hc3HOqHHoGuXfmO1L9Gh69uoxPlPW1FUDqUPTH+0enxP2lPHta5lPeUfsyTsI6YbzEfxPxDPMewR6joivROHLz6A4ZzZ9zhiRBnNP82GNXc8ZI9Jd8D8Tz1Dva2m6txo08lhr6rtovl5anJRlyTnRMvU1i/XEGAj+F7uvauF/0mQnAOcC7mm0w9gfaj2ET/5Sq/x8FbUOfb0Rn3jdTxSf+C4q4vFYxuO532hu2A/Fir7cS2CPlCjnsN//lcbGhMP8xbzU7huFqC3s7WKHT+SzH4APxvyA7Gs+hS/y/x00/8Mey3Ub8+IAcH824GIFd10x2YU5ajHJtiwm3GsJ/79Aw79J674jJv804DIFx3WVGH094HvAN0BDOY9ryy7NSfD/Aof/wEaovMA4xGTfVatNeO0912p/1zE2N/o6FSljtX7Dlw5lOVvVh/BIHfPinmzFO7rIM9A7+mpPhn2t5Fx65t//ZHqeL9WWnNU6aP8AlML3iG9bA1gPOI/5Q/IsJ4tBOVqUi9uL5XJ8umCdqg3zzrf/09lhORuNTgaj2fLObHB43f6H0+nhbHhSjCfL03I5Hl3m/x4dmLZk0TUAAA==", - "debug_symbols": "pZfNTuNMEADfxeccPNM9f7zKCqEAYRUpCiibfNInlHffaU8Xyx72Yl+oMqEL2fFM4s/p9fB8+/l0PL+9/5oefnxOz5fj6XT8+XR6f9lfj+/n/tvPabYfoU0PYTfFeSAMxAEZ0IE0kKeH2FEG6kBbIPNAr0hHr2iHDOhAGsgDvZI66kBboPNAGOiV3CEDOpAG8kCvlI5eqR1tQZoHwkAc6JXWYWc0dyZndvZQ6OeYqrMNZrs6/cRycEanONVpvX7mOTuLszrbYJmdwRmd4lSn94r3iveK94r3qveq96r3qveq96r3qveq96r3qvea95r3mvea95r3mvea95r3mvea98I8IwGJiCCKJCQjBakI5UA5UA5WVhNBFElIRqycTCrSXJYlsUhAIiKIIgnJCOVIOVIWykJZKAtloSyUhbJQFspCWSkrZaWslJWyUlbKSlkpK+VEOVFOlBPlRDlRTpQT5UQ5Uc6UM+VMeVlf2USRhGSkIFYuJs1lWWaLBCQigiiSkIwUhHKhvCy4ahKQiFi5mSiSkIzY5jmbVKS52NIbEpCI9HIMJookJCMFsXI0sbLYDm9lNQlIRARRxMrJJCMFqUhzsTU4JCAREUQRyoFyoBwoB8qRcqQcKUfKkXKkHClHypFypCyUhbJQFspCWSgLZaEslIWyUlbKSlkpK2WlrJSVslJWyolyomxrMGYTQRRJiJXz/b6b+PR/ul4OB/vw//Z1oH9J+NhfDufr9HC+nU676b/96bb80a+P/XnhdX/pr/Y78XB+7ezBt+PpYHbf/Zme/z3aks/23f9rOq0ZbyvGg62CMS/zxvm8Zr5x6fpy3TTf1+uK+Wg715iPW+fXXP/YAvOtrpiXyPlLLGvm9Wte87b5pGvmc2W+bJyva+5faerzOm+dX3P99Ov+0bDm/lGJzEvdNr/q/dfM+69543xZs/1pY/9Jq94/reVrPmycX3P+KXL/pFX77/f59Nf8Yz/avxwvfz3e3q10Oe6fTwc/fLudX769ev3/g1d4PP64vL8cXm+Xg5W+PSP3nz9iqruY5dEeEewwl37YHu/2738D", + "bytecode": "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", + "debug_symbols": "pdjNblpJEEDhd2HN4vZPVVf7VaLIwjaOkBC2iD3SyPK7T9ftOo6zmM1lkzqE1GcFaHzhY/d0fHj/dX+6PL/83t39+Ng9XE/n8+nX/fnl8fB2ermMv/3YLf5HTru7tN/lPEeZo84hc+gcbQ7b3eUx+jrKMkeaI88xlDLGUOoYMofO0eawOYYi+11d5khz5DnKHEPRMWQOnaPNYXMMpe13MhQbI82R5yhz1DmG0sfQOdocQ0nLmH1OXWKmmDlmiVljSkyN2WKGp+G18Fp4LbwWXguvhdfCa+G18Fp4Fp6FZ+FZeBaehWfhWXgWnoXXw+vh9fB6eD28Hl4Pr4fXw+vhpWUhEpGJQlRCCCUaYQRyQk4uJ49MFKISQricPRphRI/IC5GITBSiEkIgZ+SMnJELckEuyAW5IBfkglyQC3JBrsgVuSJX5IpckStyRa7IFVmQBVmQBVmQBVmQBVmQBVmRFVmRFVmRFVmRFVmR11M23m3SeszWSEQmCuFy9XBZPFxWj0YY4fJ4X0nrgVsjEZkohMvmIYQSjTCiR6xHb41EZKIQyB25I3fkjtxDzstCJCIThaiEEEo0wgjkhJyQE3JCTsgJOSEn5ISckDNyRs7IGTkjZ+SMnJEzckYuyAW5IBfkglyQC3JBXs9g9+gR6xlcIxGZGHJePCohhBKNMKJH+BmckYhMIAuyIAuyIAuyICuyIiuyIiuyIiuyIiuyIjfkhtyQG3JDbsgNuSE35IZsyIZsyIZsyIZsyIZsyIbckTtyR+7IHbkj+xnMfjnkZ3CGEX1G8TM4w+X1aikThaiEEEo0woge4WdwBnJC9jOY/erLz+AMIVz2qy4/gzOM6BF+BrN4JCIThaiEEC6rRyOM6BHrpeIaLjcPl82jEJUQQgmXu4cRPcLP4IxEZKIQlRBCCeSKXJEFWZAFWZAFWZAFWZAFWZAVWZEVWZEVWZEVWZEVWZEbckNuyA25ITfkhtyQG3JDNmRDNmRDNmRDNmRDNmRD7sh+BsvikYlCVEI8Pj/3Oz7O3L9dj0f/NPPt88341PN6uB4vb7u7y/v5vN/9czi/r//o9+vhss63w3XcO8jj5WnMAT6fzkevz/2f7eX/V8flbCyPK9Ovddm037bsl8R+sdv2a92y3y32x7XEbfspbdjP/uYz98ut+1se//HmH/tl0/9//Mr52pfb9je9/oq/5c/9Ta+fb/u1bNivC49/TXnLfuHn17rl+a/yta/LjftbHr9qmX27cb9vef3JwvmTdON+3vL4ydf7j5Qtrx+pyr7k2/Y3Pf/SeP7Fbt3XDfu68Phpktv2Nz1/Wnj+ddPvj+/7/a/9n+PW4fF0/esby0+XrqfDw/kYN5/fL4/f7n3795V7+Mbz9fryeHx6vx5d+vO1p19A/yjj7bsu+ad/DzRu1kXHTfv56T/+Pw==", "file_map": { "50": { - "source": "fn main(x: u64, y: u8, z: i16) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n}\n", + "source": "fn main(x: u64, y: u8, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176\n assert(u >> (x as u8) == 0);\n assert(z >> (x as u8) == 0);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_0.snap index 1d270b9ca2f..a8a8e8daa56 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_0.snap @@ -33,6 +33,15 @@ expression: artifact "width": 16 }, "visibility": "private" + }, + { + "name": "u", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" } ], "return_type": null, @@ -51,11 +60,11 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/+1bPW8jVRR98+F47MHxJllgRUNFQ8P4Y2O7MxJJQ0WHEI0T7xQIIRoKGpSCDiEqhCgQQjT8ADoaKjoaGio6hKgQokAIbbE7yruek+P7Jt7Ne1nvakeKZjw+797zzr33zfXMJDLnW3z/L7LHqd0nZn0TzNzui6ttA4+2ipA8o8eEZxyI54VkiGzCuDaZ1K496NjPMXyfeJx0h/z6tD8txpOOMj+P/EcdazMNbL8Vxn7RtnZeO6vt41zEb0I4bYxgjgBzBJgIMMeAOQZMlWc9wLOvnlnP4SP6DvNdbGf3//ZMfbxvjzvkK0T+IV/f8TtQ+Iuv3M41ji7ONUyujgvhITnTtfbZZ0za78B3/hbr4YqP5HgLfGA8dhr4GONvrWsRnxfsvopRRjFqB4nRdKVJZu2lECNcY1gzwb9IWnWC8CyKfbBrFF/INzeb5VmYvF/PM5emKWkq+JeIZxaEp65pRpoKx649dq0t2nXJX+2ON67dlkPTl+1eqy2OydwL56maB6lxX1OZ8yuk7TbkQW4ePA/8aTq8sqa3t0DTprUJ+yJe9yMHRlunsQfj81yjmhb+avf8B5f4qbYu+Ggr+vQUPjJWu87441rXbNfaw1zX+LQI/yrxzGFM6PzKyXegeA7F/jNB7E/KiOaDaz365GuB4I/tvurb3iNNemE0GYj93cCa9wPxl3XiBtjntVE47NF5TxxWtbcPcU0Un8IxJjwey3g89wZp1yc7rC/Hcg9sJ8o5WcOrvHudxnYBp619kpei8XOEndvPxZW2urb2SCP22SU+zwfhU8f8Ftlnn13iK/zfBM3fssdy/cC8uAW4txtwXQV3XTE5MM0x6W9ZTPrEV/ifgIZL0vqm0WNSNuD6Co7rKoFzGM+bhH8WNJTzuLZwDAT/DnB4F2yEy4tirRfBOGi12oTHcz2Yy/uOsblp7tFwbNh+Y1BwP5A65iX+uR/4gHhiDxC6J+N1PQ+iUb2G8DrJPrlnEvyHdl/F9ZsGvTzm9xPZM/F93ce9Z/qYtAvZM31EYzPAaWvRtvVMGfF51NdnXg+F/yeg+af2+LKe6bMGXKbgnvZMD9YzfQ4afkFau3qmLxtwfQXHdRW6Z/oKOHwNNsLlRbH2PAPjoNVqEx7PYc/0rWOsq2eKlbHacx1/Ogw3vo/l6ge+I56PsmcKo1FzrvB9VGPqOsP7tlxL2jixGbZPXr936XpGIv5jsx5b7T6FZk/7TcDfxYpd9ofjUS/tOs/PHr+3++pzbhMocM5MmDPey9b49zbQC+ev6dtxzP8Hc3HOqHHoGuXfmO1L9Gh69uoxPlPW1FUDqUPTH+0enxP2lPHta5lPeUfsyTsI6YbzEfxPxDPMewR6joivROHLz6A4ZzZ9zhiRBnNP82GNXc8ZI9Jd8D8Tz1Dva2m6txo08lhr6rtovl5anJRlyTnRMvU1i/XEGAj+F7uvauF/0mQnAOcC7mm0w9gfaj2ET/5Sq/x8FbUOfb0Rn3jdTxSf+C4q4vFYxuO532hu2A/Fir7cS2CPlCjnsN//lcbGhMP8xbzU7huFqC3s7WKHT+SzH4APxvyA7Gs+hS/y/x00/8Mey3Ub8+IAcH824GIFd10x2YU5ajHJtiwm3GsJ/79Aw79J674jJv804DIFx3WVGH094HvAN0BDOY9ryy7NSfD/Aof/wEaovMA4xGTfVatNeO0912p/1zE2N/o6FSljtX7Dlw5lOVvVh/BIHfPinmzFO7rIM9A7+mpPhn2t5Fx65t//ZHqeL9WWnNU6aP8AlML3iG9bA1gPOI/5Q/IsJ4tBOVqUi9uL5XJ8umCdqg3zzrf/09lhORuNTgaj2fLObHB43f6H0+nhbHhSjCfL03I5Hl3m/x4dmLZk0TUAAA==", - "debug_symbols": "pZfNTuNMEADfxeccPNM9f7zKCqEAYRUpCiibfNInlHffaU8Xyx72Yl+oMqEL2fFM4s/p9fB8+/l0PL+9/5oefnxOz5fj6XT8+XR6f9lfj+/n/tvPabYfoU0PYTfFeSAMxAEZ0IE0kKeH2FEG6kBbIPNAr0hHr2iHDOhAGsgDvZI66kBboPNAGOiV3CEDOpAG8kCvlI5eqR1tQZoHwkAc6JXWYWc0dyZndvZQ6OeYqrMNZrs6/cRycEanONVpvX7mOTuLszrbYJmdwRmd4lSn94r3iveK94r3qveq96r3qveq96r3qveq96r3qvea95r3mvea95r3mvea95r3mvea98I8IwGJiCCKJCQjBakI5UA5UA5WVhNBFElIRqycTCrSXJYlsUhAIiKIIgnJCOVIOVIWykJZKAtloSyUhbJQFspCWSkrZaWslJWyUlbKSlkpK+VEOVFOlBPlRDlRTpQT5UQ5Uc6UM+VMeVlf2USRhGSkIFYuJs1lWWaLBCQigiiSkIwUhHKhvCy4ahKQiFi5mSiSkIzY5jmbVKS52NIbEpCI9HIMJookJCMFsXI0sbLYDm9lNQlIRARRxMrJJCMFqUhzsTU4JCAREUQRyoFyoBwoB8qRcqQcKUfKkXKkHClHypFypCyUhbJQFspCWSgLZaEslIWyUlbKSlkpK2WlrJSVslJWyolyomxrMGYTQRRJiJXz/b6b+PR/ul4OB/vw//Z1oH9J+NhfDufr9HC+nU676b/96bb80a+P/XnhdX/pr/Y78XB+7ezBt+PpYHbf/Zme/z3aks/23f9rOq0ZbyvGg62CMS/zxvm8Zr5x6fpy3TTf1+uK+Wg715iPW+fXXP/YAvOtrpiXyPlLLGvm9Wte87b5pGvmc2W+bJyva+5faerzOm+dX3P99Ov+0bDm/lGJzEvdNr/q/dfM+69543xZs/1pY/9Jq94/reVrPmycX3P+KXL/pFX77/f59Nf8Yz/avxwvfz3e3q10Oe6fTwc/fLudX769ev3/g1d4PP64vL8cXm+Xg5W+PSP3nz9iqruY5dEeEewwl37YHu/2738D", + "bytecode": "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", + "debug_symbols": "pdjNblpJEEDhd2HN4vZPVVf7VaLIwjaOkBC2iD3SyPK7T9ftOo6zmM1lkzqE1GcFaHzhY/d0fHj/dX+6PL/83t39+Ng9XE/n8+nX/fnl8fB2ermMv/3YLf5HTru7tN/lPEeZo84hc+gcbQ7b3eUx+jrKMkeaI88xlDLGUOoYMofO0eawOYYi+11d5khz5DnKHEPRMWQOnaPNYXMMpe13MhQbI82R5yhz1DmG0sfQOdocQ0nLmH1OXWKmmDlmiVljSkyN2WKGp+G18Fp4LbwWXguvhdfCa+G18Fp4Fp6FZ+FZeBaehWfhWXgWnoXXw+vh9fB6eD28Hl4Pr4fXw+vhpWUhEpGJQlRCCCUaYQRyQk4uJ49MFKISQricPRphRI/IC5GITBSiEkIgZ+SMnJELckEuyAW5IBfkglyQC3JBrsgVuSJX5IpckStyRa7IFVmQBVmQBVmQBVmQBVmQBVmRFVmRFVmRFVmRFVmR11M23m3SeszWSEQmCuFy9XBZPFxWj0YY4fJ4X0nrgVsjEZkohMvmIYQSjTCiR6xHb41EZKIQyB25I3fkjtxDzstCJCIThaiEEEo0wgjkhJyQE3JCTsgJOSEn5ISckDNyRs7IGTkjZ+SMnJEzckYuyAW5IBfkglyQC3JBXs9g9+gR6xlcIxGZGHJePCohhBKNMKJH+BmckYhMIAuyIAuyIAuyICuyIiuyIiuyIiuyIiuyIjfkhtyQG3JDbsgNuSE35IZsyIZsyIZsyIZsyIZsyIbckTtyR+7IHbkj+xnMfjnkZ3CGEX1G8TM4w+X1aikThaiEEEo0woge4WdwBnJC9jOY/erLz+AMIVz2qy4/gzOM6BF+BrN4JCIThaiEEC6rRyOM6BHrpeIaLjcPl82jEJUQQgmXu4cRPcLP4IxEZKIQlRBCCeSKXJEFWZAFWZAFWZAFWZAFWZAVWZEVWZEVWZEVWZEVWZEbckNuyA25ITfkhtyQG3JDNmRDNmRDNmRDNmRDNmRD7sh+BsvikYlCVEI8Pj/3Oz7O3L9dj0f/NPPt88341PN6uB4vb7u7y/v5vN/9czi/r//o9+vhss63w3XcO8jj5WnMAT6fzkevz/2f7eX/V8flbCyPK9Ovddm037bsl8R+sdv2a92y3y32x7XEbfspbdjP/uYz98ut+1se//HmH/tl0/9//Mr52pfb9je9/oq/5c/9Ta+fb/u1bNivC49/TXnLfuHn17rl+a/yta/LjftbHr9qmX27cb9vef3JwvmTdON+3vL4ydf7j5Qtrx+pyr7k2/Y3Pf/SeP7Fbt3XDfu68Phpktv2Nz1/Wnj+ddPvj+/7/a/9n+PW4fF0/esby0+XrqfDw/kYN5/fL4/f7n3795V7+Mbz9fryeHx6vx5d+vO1p19A/yjj7bsu+ad/DzRu1kXHTfv56T/+Pw==", "file_map": { "50": { - "source": "fn main(x: u64, y: u8, z: i16) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n}\n", + "source": "fn main(x: u64, y: u8, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176\n assert(u >> (x as u8) == 0);\n assert(z >> (x as u8) == 0);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 1d270b9ca2f..a8a8e8daa56 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/bit_shifts_runtime/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -33,6 +33,15 @@ expression: artifact "width": 16 }, "visibility": "private" + }, + { + "name": "u", + "type": { + "kind": "integer", + "sign": "signed", + "width": 64 + }, + "visibility": "private" } ], "return_type": null, @@ -51,11 +60,11 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/+1bPW8jVRR98+F47MHxJllgRUNFQ8P4Y2O7MxJJQ0WHEI0T7xQIIRoKGpSCDiEqhCgQQjT8ADoaKjoaGio6hKgQokAIbbE7yruek+P7Jt7Ne1nvakeKZjw+797zzr33zfXMJDLnW3z/L7LHqd0nZn0TzNzui6ttA4+2ipA8o8eEZxyI54VkiGzCuDaZ1K496NjPMXyfeJx0h/z6tD8txpOOMj+P/EcdazMNbL8Vxn7RtnZeO6vt41zEb0I4bYxgjgBzBJgIMMeAOQZMlWc9wLOvnlnP4SP6DvNdbGf3//ZMfbxvjzvkK0T+IV/f8TtQ+Iuv3M41ji7ONUyujgvhITnTtfbZZ0za78B3/hbr4YqP5HgLfGA8dhr4GONvrWsRnxfsvopRRjFqB4nRdKVJZu2lECNcY1gzwb9IWnWC8CyKfbBrFF/INzeb5VmYvF/PM5emKWkq+JeIZxaEp65pRpoKx649dq0t2nXJX+2ON67dlkPTl+1eqy2OydwL56maB6lxX1OZ8yuk7TbkQW4ePA/8aTq8sqa3t0DTprUJ+yJe9yMHRlunsQfj81yjmhb+avf8B5f4qbYu+Ggr+vQUPjJWu87441rXbNfaw1zX+LQI/yrxzGFM6PzKyXegeA7F/jNB7E/KiOaDaz365GuB4I/tvurb3iNNemE0GYj93cCa9wPxl3XiBtjntVE47NF5TxxWtbcPcU0Un8IxJjwey3g89wZp1yc7rC/Hcg9sJ8o5WcOrvHudxnYBp619kpei8XOEndvPxZW2urb2SCP22SU+zwfhU8f8Ftlnn13iK/zfBM3fssdy/cC8uAW4txtwXQV3XTE5MM0x6W9ZTPrEV/ifgIZL0vqm0WNSNuD6Co7rKoFzGM+bhH8WNJTzuLZwDAT/DnB4F2yEy4tirRfBOGi12oTHcz2Yy/uOsblp7tFwbNh+Y1BwP5A65iX+uR/4gHhiDxC6J+N1PQ+iUb2G8DrJPrlnEvyHdl/F9ZsGvTzm9xPZM/F93ce9Z/qYtAvZM31EYzPAaWvRtvVMGfF51NdnXg+F/yeg+af2+LKe6bMGXKbgnvZMD9YzfQ4afkFau3qmLxtwfQXHdRW6Z/oKOHwNNsLlRbH2PAPjoNVqEx7PYc/0rWOsq2eKlbHacx1/Ogw3vo/l6ge+I56PsmcKo1FzrvB9VGPqOsP7tlxL2jixGbZPXr936XpGIv5jsx5b7T6FZk/7TcDfxYpd9ofjUS/tOs/PHr+3++pzbhMocM5MmDPey9b49zbQC+ev6dtxzP8Hc3HOqHHoGuXfmO1L9Gh69uoxPlPW1FUDqUPTH+0enxP2lPHta5lPeUfsyTsI6YbzEfxPxDPMewR6joivROHLz6A4ZzZ9zhiRBnNP82GNXc8ZI9Jd8D8Tz1Dva2m6txo08lhr6rtovl5anJRlyTnRMvU1i/XEGAj+F7uvauF/0mQnAOcC7mm0w9gfaj2ET/5Sq/x8FbUOfb0Rn3jdTxSf+C4q4vFYxuO532hu2A/Fir7cS2CPlCjnsN//lcbGhMP8xbzU7huFqC3s7WKHT+SzH4APxvyA7Gs+hS/y/x00/8Mey3Ub8+IAcH824GIFd10x2YU5ajHJtiwm3GsJ/79Aw79J674jJv804DIFx3WVGH094HvAN0BDOY9ryy7NSfD/Aof/wEaovMA4xGTfVatNeO0912p/1zE2N/o6FSljtX7Dlw5lOVvVh/BIHfPinmzFO7rIM9A7+mpPhn2t5Fx65t//ZHqeL9WWnNU6aP8AlML3iG9bA1gPOI/5Q/IsJ4tBOVqUi9uL5XJ8umCdqg3zzrf/09lhORuNTgaj2fLObHB43f6H0+nhbHhSjCfL03I5Hl3m/x4dmLZk0TUAAA==", - "debug_symbols": "pZfNTuNMEADfxeccPNM9f7zKCqEAYRUpCiibfNInlHffaU8Xyx72Yl+oMqEL2fFM4s/p9fB8+/l0PL+9/5oefnxOz5fj6XT8+XR6f9lfj+/n/tvPabYfoU0PYTfFeSAMxAEZ0IE0kKeH2FEG6kBbIPNAr0hHr2iHDOhAGsgDvZI66kBboPNAGOiV3CEDOpAG8kCvlI5eqR1tQZoHwkAc6JXWYWc0dyZndvZQ6OeYqrMNZrs6/cRycEanONVpvX7mOTuLszrbYJmdwRmd4lSn94r3iveK94r3qveq96r3qveq96r3qveq96r3qvea95r3mvea95r3mvea95r3mvea98I8IwGJiCCKJCQjBakI5UA5UA5WVhNBFElIRqycTCrSXJYlsUhAIiKIIgnJCOVIOVIWykJZKAtloSyUhbJQFspCWSkrZaWslJWyUlbKSlkpK+VEOVFOlBPlRDlRTpQT5UQ5Uc6UM+VMeVlf2USRhGSkIFYuJs1lWWaLBCQigiiSkIwUhHKhvCy4ahKQiFi5mSiSkIzY5jmbVKS52NIbEpCI9HIMJookJCMFsXI0sbLYDm9lNQlIRARRxMrJJCMFqUhzsTU4JCAREUQRyoFyoBwoB8qRcqQcKUfKkXKkHClHypFypCyUhbJQFspCWSgLZaEslIWyUlbKSlkpK2WlrJSVslJWyolyomxrMGYTQRRJiJXz/b6b+PR/ul4OB/vw//Z1oH9J+NhfDufr9HC+nU676b/96bb80a+P/XnhdX/pr/Y78XB+7ezBt+PpYHbf/Zme/z3aks/23f9rOq0ZbyvGg62CMS/zxvm8Zr5x6fpy3TTf1+uK+Wg715iPW+fXXP/YAvOtrpiXyPlLLGvm9Wte87b5pGvmc2W+bJyva+5faerzOm+dX3P99Ov+0bDm/lGJzEvdNr/q/dfM+69543xZs/1pY/9Jq94/reVrPmycX3P+KXL/pFX77/f59Nf8Yz/avxwvfz3e3q10Oe6fTwc/fLudX769ev3/g1d4PP64vL8cXm+Xg5W+PSP3nz9iqruY5dEeEewwl37YHu/2738D", + "bytecode": "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", + "debug_symbols": "pdjNblpJEEDhd2HN4vZPVVf7VaLIwjaOkBC2iD3SyPK7T9ftOo6zmM1lkzqE1GcFaHzhY/d0fHj/dX+6PL/83t39+Ng9XE/n8+nX/fnl8fB2ermMv/3YLf5HTru7tN/lPEeZo84hc+gcbQ7b3eUx+jrKMkeaI88xlDLGUOoYMofO0eawOYYi+11d5khz5DnKHEPRMWQOnaPNYXMMpe13MhQbI82R5yhz1DmG0sfQOdocQ0nLmH1OXWKmmDlmiVljSkyN2WKGp+G18Fp4LbwWXguvhdfCa+G18Fp4Fp6FZ+FZeBaehWfhWXgWnoXXw+vh9fB6eD28Hl4Pr4fXw+vhpWUhEpGJQlRCCCUaYQRyQk4uJ49MFKISQricPRphRI/IC5GITBSiEkIgZ+SMnJELckEuyAW5IBfkglyQC3JBrsgVuSJX5IpckStyRa7IFVmQBVmQBVmQBVmQBVmQBVmRFVmRFVmRFVmRFVmR11M23m3SeszWSEQmCuFy9XBZPFxWj0YY4fJ4X0nrgVsjEZkohMvmIYQSjTCiR6xHb41EZKIQyB25I3fkjtxDzstCJCIThaiEEEo0wgjkhJyQE3JCTsgJOSEn5ISckDNyRs7IGTkjZ+SMnJEzckYuyAW5IBfkglyQC3JBXs9g9+gR6xlcIxGZGHJePCohhBKNMKJH+BmckYhMIAuyIAuyIAuyICuyIiuyIiuyIiuyIiuyIjfkhtyQG3JDbsgNuSE35IZsyIZsyIZsyIZsyIZsyIbckTtyR+7IHbkj+xnMfjnkZ3CGEX1G8TM4w+X1aikThaiEEEo0woge4WdwBnJC9jOY/erLz+AMIVz2qy4/gzOM6BF+BrN4JCIThaiEEC6rRyOM6BHrpeIaLjcPl82jEJUQQgmXu4cRPcLP4IxEZKIQlRBCCeSKXJEFWZAFWZAFWZAFWZAFWZAVWZEVWZEVWZEVWZEVWZEbckNuyA25ITfkhtyQG3JDNmRDNmRDNmRDNmRDNmRD7sh+BsvikYlCVEI8Pj/3Oz7O3L9dj0f/NPPt88341PN6uB4vb7u7y/v5vN/9czi/r//o9+vhss63w3XcO8jj5WnMAT6fzkevz/2f7eX/V8flbCyPK9Ovddm037bsl8R+sdv2a92y3y32x7XEbfspbdjP/uYz98ut+1se//HmH/tl0/9//Mr52pfb9je9/oq/5c/9Ta+fb/u1bNivC49/TXnLfuHn17rl+a/yta/LjftbHr9qmX27cb9vef3JwvmTdON+3vL4ydf7j5Qtrx+pyr7k2/Y3Pf/SeP7Fbt3XDfu68Phpktv2Nz1/Wnj+ddPvj+/7/a/9n+PW4fF0/esby0+XrqfDw/kYN5/fL4/f7n3795V7+Mbz9fryeHx6vx5d+vO1p19A/yjj7bsu+ad/DzRu1kXHTfv56T/+Pw==", "file_map": { "50": { - "source": "fn main(x: u64, y: u8, z: i16) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n}\n", + "source": "fn main(x: u64, y: u8, z: i16, u: i64) {\n // runtime shifts on compile-time known values\n assert(64 << y == 128);\n assert(64 >> y == 32);\n // runtime shifts on runtime values\n assert(x << y == 128);\n assert(x >> y == 32);\n // regression tests for issue #8176\n assert(u >> (x as u8) == 0);\n assert(z >> (x as u8) == 0);\n\n // Bit-shift with signed integers\n let mut a: i8 = y as i8;\n let mut b: i8 = x as i8;\n assert(b << 1 == -128);\n assert(b >> 2 == 16);\n assert(b >> y == 32);\n a = -a;\n assert(a << 7 == -128);\n assert(a << y == -2);\n\n assert(x >> (x as u8) == 0);\n\n assert_eq(z >> 3, -97);\n}\n", "path": "" } }, diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index c9478fdd61b..7bbf8c4ccc0 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -20,8 +20,8 @@ expression: artifact "return_type": null, "error_types": {} }, - "bytecode": "H4sIAAAAAAAA/9Va0VLbMBA823HsEChQQqGFFlpCaYAHn52A88avQHH+/xMagW8qZJFhJnszys14bGSx7N6dVkAU0WvcLq9Z+xwtr6S9m8iXV699TqgbMu+hvRfrBQOxCg9dFHatiF1GVm5z6zlua2DqkS6v/vLKZI5dOPtKrG92xxLPWM8zlnrG+p6xzDOW0/8mkRhgE/amaaribjpt7suGK34syvlTPSums6e7mmue1bPnsq6qpp7W9/On+X0x52nV8GI2rxYtWATAahavEeOwnhMc1ryHw+IUhtVwH4b1lzMYVs05YU0JbJpl3q6zGIs7zYHragDUq5BDVsphiczhFmE9U8LVvC7PDIg1BGsG1/fFZ4C9zabGQ09/r5vHbQrbwwy/bQXdO2HrZi3dn8C6JdBe0Qdi7VLYXmG0AvuRTY13FXpnj8L2CsNvT0H3fti6WUv3Z9oMr0iBWAcUtlcYrcB+ZFPjA4XeGVHYXmH4jRR0H4atm7V0f6HN8IoeEOuIwvYKoxXYj2xqfKTQO8cUtlcYfscKur+GrZu1dH+jzfCKBIh1QmF7hdEK7Ec2NT5R6J1TCtsrDL9TBd3fw9bNWrp/0GZ4RQzEOqOwvcLgAfuRTY3PFHrnnML2CsPvXEH3z7B1s5buX7QZXhEBsS6AdZHP+GPqRrgHOhq9Ax386usS4/Z+KQmRwwxj6h5wMJNyh1SimMT1PswueEy4prxUKi56ISI1/6awN23Tk8CNgY3ZXhDexK9wHF/+2RPT24NGaCMzdb8C4rZnhBZjYB5s/X+0E4FqXF8i1m2uCTCpGjk0xZlYxULpXrWzE1iDjYnOD7J+di6u2/uNkJZd3AycO4lC7+ITYKFvgFi3QCw7p7dWTtG7x6QtJhr3hjZjgVwTdtfoOTxXhayL/fYux3lTCyMB8hP8vg4+C36mg19l1A17LHXy6vstRjgNnJyDuT5GHn6J8zNdjvacHnXD3Yx6znjygbm+vpR3ex5+7vcNPFztMemtHeqGWxf5ay99Byuz3tvzM2euVg0PPJxc7vJuS4dDKfhDHfzCt6a2rOeh8076ytef0Ttfx8591dxoBa6vpwRTamXzFR1unxxauBr+N9LB99bq0HoeOTrtfD+AOAierNeUuhE772Suu2YiPD92ufj2AgnpmZE1Jvn8B3x5JnfUNQAA", - "debug_symbols": "jdLBboQgEAbgd+HswZnBbruv0jQGFTckBA2rTRrjuxf5sd09NOllUIb/iwibGmy33loXxumuru+b6qLz3t1aP/VmcVNIs9teqfO1XaK1aUo99FNqNtGGRV3D6n2lPo1f86L7bEIeFxNTt66UDUMaEzg6b4+nvfpN139HqaYSpvryE2/+n2c580JP+Y/0ZnoXn3asKC2sFOcquepcm1xfcr3k+prrW65UY0CaECfkCQBBIBAEg4AQFIbC5RugMBSGwlAYCkNhKAxFoAgUKVuBIlAEikARKAJFoGgoGoqGossfgaKhaCgaioaioTRQGihNUng/zio603lbrti4hv7hxi1f89k57+Qcp94Oa7THWeVeOr1v", + "bytecode": "H4sIAAAAAAAA/9Va21LbMBBd27maQrkktNBCgZZCeNLaDjhv/AoU5/8/oRa16FYomc7k7IyyMxorknK8Zy/HmYkT+mN37ai6edKOrLtaG7Wj181Tem/u3GN3NZsZ47AaE3AXg83GpIEYpH4A5XBraRdUaZliEEtzX1XNQ9FwyU+mWDzXc1PNn+9rrnlez1+KuiybuqofFs+LB7Pgqmx4OV+UzdKa4QSAtewcS4HJ7Ym40opi3NTfZAWu2cyARW70ityYWhG7kLF1/WBzafPab8egHcNub9yOnOjfRpJN5ua9wFo/sDYIrA0Da6PA2jiwltPfIkEXIYn7AhPASB8zQgnOctnDYb30cViLAQ6LhzCshkcwrF88hmHVnBNW5MAiXORd36ZY3CoH9tUOkK9CDFkphgUyhh8Iq5nOfM6b+jkGYu2COYPz+6ozwNpmm+Ndwj979yhuDbP+7Snw/hg3b9bivQ/m7QytFSMg1gHFrRWWK7Ae2eb4QKF2DilurbD+HSrwPoqbN2vxntB2aMUQiDWluLXCcgXWI9scTxVq55ji1grr37EC709x82Yt3p9pO7RiAMQ6obi1wnIF1iPbHJ8o1M4pxa0V1r9TBd5f4ubNWry/0nZoRR+IdUZxa4XlCqxHtjk+U6idc4pbK6x/5wq8v8XNm7V4X9B2aEUPiHVJcWuF5QqsR75oMS4VaueK4tYK69+VAu/vcfNmLd4/aDu0IgNiXRO2r1ORlxB3s5mxrc0MiGdzfi38BeEaGYOfWsGwgQA261sw0I11Q3ELik3QDb0vAsRDXeY9ZCgOEhMdH2T+ZCxuu+vMOe3eFrIbF97arFuThn4t8AaY/BkQ6w6IJWN6J2Kq0fS3CrgzwjaNxiuRId5mM+Nbwj6del7e15nrM/caonvTLhcYwKdy4fB3dPBf//HxLRfzHW/PiVYv8L1kxefUu647m6zB3Q3sOcyj7ir9dTwOuquLZV/gImPp8Ac6+Ozwhzr4ZagW5JqLWybuT97c+TT2Yg729SkJ+Jd59/R9lGdC9ev/OPF/tGT/cTZUv25vP+Cf/71xwFe55mor1At+XpxG9VdgDcW+PD/0zmrl8CjgU7Li3lMdH956aqKDH9TXqZhPPJ6yrh5BPjg8VwN9em+pt7fqOZfg/WPfl5C+OHM1MxFrLp6/AQ7IWHukNAAA", + "debug_symbols": "jdLBboQgEAbgd+HswZnBbruv0jQGFTckBA2rTRrjuxf5sd09NOllUIb/iwibGmy33loXxumuru+b6qLz3t1aP/VmcVNIs9teqfO1XaK1aUo99FNqNtGGRV3D6n2lPo1f86L7bEIeFxNTt66UDUMaEzg6b4+nvfpN139HqaYSpvryE2/+n2c580JP+Y/0ZnoXn3asKC2sFOcquepcm1xfcr3k+prrW65UY0CaECfkCQBBIBAEg4AQFIbC5RugMBSGwlAYCkNhKAxFoAgUKVuBIlAEikARKAJFoGgoGoqGossfgaKhaCgaioaioTRQmqTwfhxSdKbzttytcQ39w1Vbvuazc17GOU69HdZoj0PKvXRs3w==", "file_map": { "50": { "source": "fn main(x: u8) {\n // This would previously overflow in ACIR. Now it returns zero.\n let value = 1 >> x;\n assert_eq(value, 0);\n}\n", @@ -32,8 +32,8 @@ expression: artifact "main" ], "brillig_names": [ - "directive_to_radix", "directive_integer_quotient", + "directive_to_radix", "directive_invert" ] } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_0.snap index c9478fdd61b..7bbf8c4ccc0 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_0.snap @@ -20,8 +20,8 @@ expression: artifact "return_type": null, "error_types": {} }, - "bytecode": "H4sIAAAAAAAA/9Va0VLbMBA823HsEChQQqGFFlpCaYAHn52A88avQHH+/xMagW8qZJFhJnszys14bGSx7N6dVkAU0WvcLq9Z+xwtr6S9m8iXV699TqgbMu+hvRfrBQOxCg9dFHatiF1GVm5z6zlua2DqkS6v/vLKZI5dOPtKrG92xxLPWM8zlnrG+p6xzDOW0/8mkRhgE/amaaribjpt7suGK34syvlTPSums6e7mmue1bPnsq6qpp7W9/On+X0x52nV8GI2rxYtWATAahavEeOwnhMc1ryHw+IUhtVwH4b1lzMYVs05YU0JbJpl3q6zGIs7zYHragDUq5BDVsphiczhFmE9U8LVvC7PDIg1BGsG1/fFZ4C9zabGQ09/r5vHbQrbwwy/bQXdO2HrZi3dn8C6JdBe0Qdi7VLYXmG0AvuRTY13FXpnj8L2CsNvT0H3fti6WUv3Z9oMr0iBWAcUtlcYrcB+ZFPjA4XeGVHYXmH4jRR0H4atm7V0f6HN8IoeEOuIwvYKoxXYj2xqfKTQO8cUtlcYfscKur+GrZu1dH+jzfCKBIh1QmF7hdEK7Ec2NT5R6J1TCtsrDL9TBd3fw9bNWrp/0GZ4RQzEOqOwvcLgAfuRTY3PFHrnnML2CsPvXEH3z7B1s5buX7QZXhEBsS6AdZHP+GPqRrgHOhq9Ax386usS4/Z+KQmRwwxj6h5wMJNyh1SimMT1PswueEy4prxUKi56ISI1/6awN23Tk8CNgY3ZXhDexK9wHF/+2RPT24NGaCMzdb8C4rZnhBZjYB5s/X+0E4FqXF8i1m2uCTCpGjk0xZlYxULpXrWzE1iDjYnOD7J+di6u2/uNkJZd3AycO4lC7+ITYKFvgFi3QCw7p7dWTtG7x6QtJhr3hjZjgVwTdtfoOTxXhayL/fYux3lTCyMB8hP8vg4+C36mg19l1A17LHXy6vstRjgNnJyDuT5GHn6J8zNdjvacHnXD3Yx6znjygbm+vpR3ex5+7vcNPFztMemtHeqGWxf5ay99Byuz3tvzM2euVg0PPJxc7vJuS4dDKfhDHfzCt6a2rOeh8076ytef0Ttfx8591dxoBa6vpwRTamXzFR1unxxauBr+N9LB99bq0HoeOTrtfD+AOAierNeUuhE772Suu2YiPD92ufj2AgnpmZE1Jvn8B3x5JnfUNQAA", - "debug_symbols": "jdLBboQgEAbgd+HswZnBbruv0jQGFTckBA2rTRrjuxf5sd09NOllUIb/iwibGmy33loXxumuru+b6qLz3t1aP/VmcVNIs9teqfO1XaK1aUo99FNqNtGGRV3D6n2lPo1f86L7bEIeFxNTt66UDUMaEzg6b4+nvfpN139HqaYSpvryE2/+n2c580JP+Y/0ZnoXn3asKC2sFOcquepcm1xfcr3k+prrW65UY0CaECfkCQBBIBAEg4AQFIbC5RugMBSGwlAYCkNhKAxFoAgUKVuBIlAEikARKAJFoGgoGoqGossfgaKhaCgaioaioTRQGihNUng/zio603lbrti4hv7hxi1f89k57+Qcp94Oa7THWeVeOr1v", + "bytecode": "H4sIAAAAAAAA/9Va21LbMBBd27maQrkktNBCgZZCeNLaDjhv/AoU5/8/oRa16FYomc7k7IyyMxorknK8Zy/HmYkT+mN37ai6edKOrLtaG7Wj181Tem/u3GN3NZsZ47AaE3AXg83GpIEYpH4A5XBraRdUaZliEEtzX1XNQ9FwyU+mWDzXc1PNn+9rrnlez1+KuiybuqofFs+LB7Pgqmx4OV+UzdKa4QSAtewcS4HJ7Ym40opi3NTfZAWu2cyARW70ityYWhG7kLF1/WBzafPab8egHcNub9yOnOjfRpJN5ua9wFo/sDYIrA0Da6PA2jiwltPfIkEXIYn7AhPASB8zQgnOctnDYb30cViLAQ6LhzCshkcwrF88hmHVnBNW5MAiXORd36ZY3CoH9tUOkK9CDFkphgUyhh8Iq5nOfM6b+jkGYu2COYPz+6ozwNpmm+Ndwj979yhuDbP+7Snw/hg3b9bivQ/m7QytFSMg1gHFrRWWK7Ae2eb4QKF2DilurbD+HSrwPoqbN2vxntB2aMUQiDWluLXCcgXWI9scTxVq55ji1grr37EC709x82Yt3p9pO7RiAMQ6obi1wnIF1iPbHJ8o1M4pxa0V1r9TBd5f4ubNWry/0nZoRR+IdUZxa4XlCqxHtjk+U6idc4pbK6x/5wq8v8XNm7V4X9B2aEUPiHVJcWuF5QqsR75oMS4VaueK4tYK69+VAu/vcfNmLd4/aDu0IgNiXRO2r1ORlxB3s5mxrc0MiGdzfi38BeEaGYOfWsGwgQA261sw0I11Q3ELik3QDb0vAsRDXeY9ZCgOEhMdH2T+ZCxuu+vMOe3eFrIbF97arFuThn4t8AaY/BkQ6w6IJWN6J2Kq0fS3CrgzwjaNxiuRId5mM+Nbwj6del7e15nrM/caonvTLhcYwKdy4fB3dPBf//HxLRfzHW/PiVYv8L1kxefUu647m6zB3Q3sOcyj7ir9dTwOuquLZV/gImPp8Ac6+Ozwhzr4ZagW5JqLWybuT97c+TT2Yg729SkJ+Jd59/R9lGdC9ev/OPF/tGT/cTZUv25vP+Cf/71xwFe55mor1At+XpxG9VdgDcW+PD/0zmrl8CjgU7Li3lMdH956aqKDH9TXqZhPPJ6yrh5BPjg8VwN9em+pt7fqOZfg/WPfl5C+OHM1MxFrLp6/AQ7IWHukNAAA", + "debug_symbols": "jdLBboQgEAbgd+HswZnBbruv0jQGFTckBA2rTRrjuxf5sd09NOllUIb/iwibGmy33loXxumuru+b6qLz3t1aP/VmcVNIs9teqfO1XaK1aUo99FNqNtGGRV3D6n2lPo1f86L7bEIeFxNTt66UDUMaEzg6b4+nvfpN139HqaYSpvryE2/+n2c580JP+Y/0ZnoXn3asKC2sFOcquepcm1xfcr3k+prrW65UY0CaECfkCQBBIBAEg4AQFIbC5RugMBSGwlAYCkNhKAxFoAgUKVuBIlAEikARKAJFoGgoGoqGossfgaKhaCgaioaioTRQmqTwfhxSdKbzttytcQ39w1Vbvuazc17GOU69HdZoj0PKvXRs3w==", "file_map": { "50": { "source": "fn main(x: u8) {\n // This would previously overflow in ACIR. Now it returns zero.\n let value = 1 >> x;\n assert_eq(value, 0);\n}\n", @@ -32,8 +32,8 @@ expression: artifact "main" ], "brillig_names": [ - "directive_to_radix", "directive_integer_quotient", + "directive_to_radix", "directive_invert" ] } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index c9478fdd61b..7bbf8c4ccc0 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/shift_right_overflow/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -20,8 +20,8 @@ expression: artifact "return_type": null, "error_types": {} }, - "bytecode": "H4sIAAAAAAAA/9Va0VLbMBA823HsEChQQqGFFlpCaYAHn52A88avQHH+/xMagW8qZJFhJnszys14bGSx7N6dVkAU0WvcLq9Z+xwtr6S9m8iXV699TqgbMu+hvRfrBQOxCg9dFHatiF1GVm5z6zlua2DqkS6v/vLKZI5dOPtKrG92xxLPWM8zlnrG+p6xzDOW0/8mkRhgE/amaaribjpt7suGK34syvlTPSums6e7mmue1bPnsq6qpp7W9/On+X0x52nV8GI2rxYtWATAahavEeOwnhMc1ryHw+IUhtVwH4b1lzMYVs05YU0JbJpl3q6zGIs7zYHragDUq5BDVsphiczhFmE9U8LVvC7PDIg1BGsG1/fFZ4C9zabGQ09/r5vHbQrbwwy/bQXdO2HrZi3dn8C6JdBe0Qdi7VLYXmG0AvuRTY13FXpnj8L2CsNvT0H3fti6WUv3Z9oMr0iBWAcUtlcYrcB+ZFPjA4XeGVHYXmH4jRR0H4atm7V0f6HN8IoeEOuIwvYKoxXYj2xqfKTQO8cUtlcYfscKur+GrZu1dH+jzfCKBIh1QmF7hdEK7Ec2NT5R6J1TCtsrDL9TBd3fw9bNWrp/0GZ4RQzEOqOwvcLgAfuRTY3PFHrnnML2CsPvXEH3z7B1s5buX7QZXhEBsS6AdZHP+GPqRrgHOhq9Ax386usS4/Z+KQmRwwxj6h5wMJNyh1SimMT1PswueEy4prxUKi56ISI1/6awN23Tk8CNgY3ZXhDexK9wHF/+2RPT24NGaCMzdb8C4rZnhBZjYB5s/X+0E4FqXF8i1m2uCTCpGjk0xZlYxULpXrWzE1iDjYnOD7J+di6u2/uNkJZd3AycO4lC7+ITYKFvgFi3QCw7p7dWTtG7x6QtJhr3hjZjgVwTdtfoOTxXhayL/fYux3lTCyMB8hP8vg4+C36mg19l1A17LHXy6vstRjgNnJyDuT5GHn6J8zNdjvacHnXD3Yx6znjygbm+vpR3ex5+7vcNPFztMemtHeqGWxf5ay99Byuz3tvzM2euVg0PPJxc7vJuS4dDKfhDHfzCt6a2rOeh8076ytef0Ttfx8591dxoBa6vpwRTamXzFR1unxxauBr+N9LB99bq0HoeOTrtfD+AOAierNeUuhE772Suu2YiPD92ufj2AgnpmZE1Jvn8B3x5JnfUNQAA", - "debug_symbols": "jdLBboQgEAbgd+HswZnBbruv0jQGFTckBA2rTRrjuxf5sd09NOllUIb/iwibGmy33loXxumuru+b6qLz3t1aP/VmcVNIs9teqfO1XaK1aUo99FNqNtGGRV3D6n2lPo1f86L7bEIeFxNTt66UDUMaEzg6b4+nvfpN139HqaYSpvryE2/+n2c580JP+Y/0ZnoXn3asKC2sFOcquepcm1xfcr3k+prrW65UY0CaECfkCQBBIBAEg4AQFIbC5RugMBSGwlAYCkNhKAxFoAgUKVuBIlAEikARKAJFoGgoGoqGossfgaKhaCgaioaioTRQGihNUng/zio603lbrti4hv7hxi1f89k57+Qcp94Oa7THWeVeOr1v", + "bytecode": "H4sIAAAAAAAA/9Va21LbMBBd27maQrkktNBCgZZCeNLaDjhv/AoU5/8/oRa16FYomc7k7IyyMxorknK8Zy/HmYkT+mN37ai6edKOrLtaG7Wj181Tem/u3GN3NZsZ47AaE3AXg83GpIEYpH4A5XBraRdUaZliEEtzX1XNQ9FwyU+mWDzXc1PNn+9rrnlez1+KuiybuqofFs+LB7Pgqmx4OV+UzdKa4QSAtewcS4HJ7Ym40opi3NTfZAWu2cyARW70ityYWhG7kLF1/WBzafPab8egHcNub9yOnOjfRpJN5ua9wFo/sDYIrA0Da6PA2jiwltPfIkEXIYn7AhPASB8zQgnOctnDYb30cViLAQ6LhzCshkcwrF88hmHVnBNW5MAiXORd36ZY3CoH9tUOkK9CDFkphgUyhh8Iq5nOfM6b+jkGYu2COYPz+6ozwNpmm+Ndwj979yhuDbP+7Snw/hg3b9bivQ/m7QytFSMg1gHFrRWWK7Ae2eb4QKF2DilurbD+HSrwPoqbN2vxntB2aMUQiDWluLXCcgXWI9scTxVq55ji1grr37EC709x82Yt3p9pO7RiAMQ6obi1wnIF1iPbHJ8o1M4pxa0V1r9TBd5f4ubNWry/0nZoRR+IdUZxa4XlCqxHtjk+U6idc4pbK6x/5wq8v8XNm7V4X9B2aEUPiHVJcWuF5QqsR75oMS4VaueK4tYK69+VAu/vcfNmLd4/aDu0IgNiXRO2r1ORlxB3s5mxrc0MiGdzfi38BeEaGYOfWsGwgQA261sw0I11Q3ELik3QDb0vAsRDXeY9ZCgOEhMdH2T+ZCxuu+vMOe3eFrIbF97arFuThn4t8AaY/BkQ6w6IJWN6J2Kq0fS3CrgzwjaNxiuRId5mM+Nbwj6del7e15nrM/caonvTLhcYwKdy4fB3dPBf//HxLRfzHW/PiVYv8L1kxefUu647m6zB3Q3sOcyj7ir9dTwOuquLZV/gImPp8Ac6+Ozwhzr4ZagW5JqLWybuT97c+TT2Yg729SkJ+Jd59/R9lGdC9ev/OPF/tGT/cTZUv25vP+Cf/71xwFe55mor1At+XpxG9VdgDcW+PD/0zmrl8CjgU7Li3lMdH956aqKDH9TXqZhPPJ6yrh5BPjg8VwN9em+pt7fqOZfg/WPfl5C+OHM1MxFrLp6/AQ7IWHukNAAA", + "debug_symbols": "jdLBboQgEAbgd+HswZnBbruv0jQGFTckBA2rTRrjuxf5sd09NOllUIb/iwibGmy33loXxumuru+b6qLz3t1aP/VmcVNIs9teqfO1XaK1aUo99FNqNtGGRV3D6n2lPo1f86L7bEIeFxNTt66UDUMaEzg6b4+nvfpN139HqaYSpvryE2/+n2c580JP+Y/0ZnoXn3asKC2sFOcquepcm1xfcr3k+prrW65UY0CaECfkCQBBIBAEg4AQFIbC5RugMBSGwlAYCkNhKAxFoAgUKVuBIlAEikARKAJFoGgoGoqGossfgaKhaCgaioaioTRQmqTwfhxSdKbzttytcQ39w1Vbvuazc17GOU69HdZoj0PKvXRs3w==", "file_map": { "50": { "source": "fn main(x: u8) {\n // This would previously overflow in ACIR. Now it returns zero.\n let value = 1 >> x;\n assert_eq(value, 0);\n}\n", @@ -32,8 +32,8 @@ expression: artifact "main" ], "brillig_names": [ - "directive_to_radix", "directive_integer_quotient", + "directive_to_radix", "directive_invert" ] } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index e89f037bc52..44bef3888de 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -55,8 +55,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZbLjuIwEEX/JessXOXyq39lNGoFCK1IUUBpaGmE+t+nnKpi6MVsnE3OhXAPzsNOHt1pPNw/3qflfPns3n49usM6zfP08T5fjsNtuiz87eO77+zj+20dR/6qe9nPreuwjsute1vu89x3X8N83370eR2Wjbdh5b2u78blxGTheZrHmr77f233/yqg1zJgftZDS59SSz+S9WPZ188t40cXtI/g9vWxZfxI0foB9vVT0/hzsn7BXX0PLeP3mK1PLeP34fn/Eff1c9P4i42fnN/Xx5bxky/WJ9rXjy3jp2yLD+W4qx9cSz8815/QNP9e+tTUjzb/QoJ9/dJy/0dn928Ev6/vm/rBrl9MP6/fb/40HKf1xxOvQ14y+s7zhe874h/2Xdi2cdumbZu3bdm24AQgQAH3+bQBC3j0EARRkARZUDagE4AABV4gFhQLigXFgmJBsXi28Gz1bOFJ41HgBSQIgihIgiwoG8gJxEJiIbGQWEgsJBZiC/BZJtYAMEt97PKJYxHw3RugPnyZrIJ6Qn19LDJJGZSsAz6MUH18HCErizA6JShR6ZWkDMqoVF9UX1RfUl9SX1JfUl9SX1JfUl9SX1JfUl9WX1ZfVl9WX1ZfVl9WX1ZfVl9WX1FfUV9RX1FfUV9RX1FfUV9RX1EfOGcBLKAFb4EsBAvRQrKQLZgZzAxmBjODmcHMYGYwc50TUGrI9Y2lhqKhzgwJYAEteAtkIViIFpIFM6OZvZm9meuMQaihmrEGshAsRAvJQjX7GqqZ6rR3FsACWvAWqrkuFXUu4bZYVHNdor6GdRoO86hv4Of7cnx5Ib/9udoee2W/rpfjeLqvY13Ktn28uP0F", + "bytecode": "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", + "debug_symbols": "pdfLTuNAEAXQf/E6C1d3VT/4ldEImWBQJCuJTII0Qvz7VLvqMrCYTXvje/OoQ+fRNvkYnuen++vj6fxyeRsefn0MT+tpWU6vj8vlON1Ol7Pe+/F5GHDz8bbOs941fHtcp67TOp9vw8P5viyH4X1a7tuT3q7TecvbtOqj42GYz8+aCr6clrm1z8O/6fH/oxSiD1MoX+PSM8+5Zz4x5lPdN1961h9G8flA47750LP+wAnzQvvmc9f6S8Z8DbvmI/WsP4aCee5Zf5Svv5/CvvnStf6K9fMY982HnvVzrJhn3jefetbPBScfLmnXvIw98/J1/pGu/fdtnrvmE/afZNo3X3u+/2nE9zdR3Dcfu+YFn1/KPz+/33prOp7WH1e8Iegp4zBE/eAPA+sTD4Nsx7Qd83Ys27FuRxotyCJY6Ly+baSArp7EIllki2JRtwijBVkEi2hhSjAlmBJMCaYEU6IqulujKrppYrCIFmwhFskiWxSLugWPFqawKWwKm8KmsCmsCum7zMoQadZ22dU3TiHSb69Qu/hqKkXtDY3tsqjJnuKpHOnLkObp65DiWS3T6EmewTN6sqd4Jk/3knvJvexedi+7l93L7mX3snvZvexedq+4V9wr7hX3invFveJeca+4V9yr7lX3qnvVvepeda+6V92r7lX3aBxRCCWgRBRGEZSEklEKCmSCTJAJMkEmyAS57QiqreT2j0orBaV6aTvDCqEElIjCKIKSUCAHyAFyhBwhR8gRcoQcIUfIEXKEHCEzZIbMkBkyQ2bIDJkhM2SGLJAFskAWyAJZIAtkgSyQBXKCnCAnyAlygpwgJ8gJcoKcILdtFqiVJodWAkpEYRRBaXJspcncSkGpXtqGs0IoTW4n4LbnQjsFt00X2on/fVpP09My+++al/v5+O1nzu3PFY/gh9B1vRzn5/s6twvE9pheMv4C", "file_map": { "50": { "source": "fn main(x: u128, y: u128, z: u8) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_0.snap index e89f037bc52..44bef3888de 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_0.snap @@ -55,8 +55,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZbLjuIwEEX/JessXOXyq39lNGoFCK1IUUBpaGmE+t+nnKpi6MVsnE3OhXAPzsNOHt1pPNw/3qflfPns3n49usM6zfP08T5fjsNtuiz87eO77+zj+20dR/6qe9nPreuwjsute1vu89x3X8N83370eR2Wjbdh5b2u78blxGTheZrHmr77f233/yqg1zJgftZDS59SSz+S9WPZ188t40cXtI/g9vWxZfxI0foB9vVT0/hzsn7BXX0PLeP3mK1PLeP34fn/Eff1c9P4i42fnN/Xx5bxky/WJ9rXjy3jp2yLD+W4qx9cSz8815/QNP9e+tTUjzb/QoJ9/dJy/0dn928Ev6/vm/rBrl9MP6/fb/40HKf1xxOvQ14y+s7zhe874h/2Xdi2cdumbZu3bdm24AQgQAH3+bQBC3j0EARRkARZUDagE4AABV4gFhQLigXFgmJBsXi28Gz1bOFJ41HgBSQIgihIgiwoG8gJxEJiIbGQWEgsJBZiC/BZJtYAMEt97PKJYxHw3RugPnyZrIJ6Qn19LDJJGZSsAz6MUH18HCErizA6JShR6ZWkDMqoVF9UX1RfUl9SX1JfUl9SX1JfUl9SX1JfUl9WX1ZfVl9WX1ZfVl9WX1ZfVl9WX1FfUV9RX1FfUV9RX1FfUV9RX1EfOGcBLKAFb4EsBAvRQrKQLZgZzAxmBjODmcHMYGYwc50TUGrI9Y2lhqKhzgwJYAEteAtkIViIFpIFM6OZvZm9meuMQaihmrEGshAsRAvJQjX7GqqZ6rR3FsACWvAWqrkuFXUu4bZYVHNdor6GdRoO86hv4Of7cnx5Ib/9udoee2W/rpfjeLqvY13Ktn28uP0F", + "bytecode": "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", + "debug_symbols": "pdfLTuNAEAXQf/E6C1d3VT/4ldEImWBQJCuJTII0Qvz7VLvqMrCYTXvje/OoQ+fRNvkYnuen++vj6fxyeRsefn0MT+tpWU6vj8vlON1Ol7Pe+/F5GHDz8bbOs941fHtcp67TOp9vw8P5viyH4X1a7tuT3q7TecvbtOqj42GYz8+aCr6clrm1z8O/6fH/oxSiD1MoX+PSM8+5Zz4x5lPdN1961h9G8flA47750LP+wAnzQvvmc9f6S8Z8DbvmI/WsP4aCee5Zf5Svv5/CvvnStf6K9fMY982HnvVzrJhn3jefetbPBScfLmnXvIw98/J1/pGu/fdtnrvmE/afZNo3X3u+/2nE9zdR3Dcfu+YFn1/KPz+/33prOp7WH1e8Iegp4zBE/eAPA+sTD4Nsx7Qd83Ys27FuRxotyCJY6Ly+baSArp7EIllki2JRtwijBVkEi2hhSjAlmBJMCaYEU6IqulujKrppYrCIFmwhFskiWxSLugWPFqawKWwKm8KmsCmsCum7zMoQadZ22dU3TiHSb69Qu/hqKkXtDY3tsqjJnuKpHOnLkObp65DiWS3T6EmewTN6sqd4Jk/3knvJvexedi+7l93L7mX3snvZvexedq+4V9wr7hX3invFveJeca+4V9yr7lX3qnvVvepeda+6V92r7lX3aBxRCCWgRBRGEZSEklEKCmSCTJAJMkEmyAS57QiqreT2j0orBaV6aTvDCqEElIjCKIKSUCAHyAFyhBwhR8gRcoQcIUfIEXKEHCEzZIbMkBkyQ2bIDJkhM2SGLJAFskAWyAJZIAtkgSyQBXKCnCAnyAlygpwgJ8gJcoKcILdtFqiVJodWAkpEYRRBaXJspcncSkGpXtqGs0IoTW4n4LbnQjsFt00X2on/fVpP09My+++al/v5+O1nzu3PFY/gh9B1vRzn5/s6twvE9pheMv4C", "file_map": { "50": { "source": "fn main(x: u128, y: u128, z: u8) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index e89f037bc52..44bef3888de 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/u128_type/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -55,8 +55,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZbLjuIwEEX/JessXOXyq39lNGoFCK1IUUBpaGmE+t+nnKpi6MVsnE3OhXAPzsNOHt1pPNw/3qflfPns3n49usM6zfP08T5fjsNtuiz87eO77+zj+20dR/6qe9nPreuwjsute1vu89x3X8N83370eR2Wjbdh5b2u78blxGTheZrHmr77f233/yqg1zJgftZDS59SSz+S9WPZ188t40cXtI/g9vWxZfxI0foB9vVT0/hzsn7BXX0PLeP3mK1PLeP34fn/Eff1c9P4i42fnN/Xx5bxky/WJ9rXjy3jp2yLD+W4qx9cSz8815/QNP9e+tTUjzb/QoJ9/dJy/0dn928Ev6/vm/rBrl9MP6/fb/40HKf1xxOvQ14y+s7zhe874h/2Xdi2cdumbZu3bdm24AQgQAH3+bQBC3j0EARRkARZUDagE4AABV4gFhQLigXFgmJBsXi28Gz1bOFJ41HgBSQIgihIgiwoG8gJxEJiIbGQWEgsJBZiC/BZJtYAMEt97PKJYxHw3RugPnyZrIJ6Qn19LDJJGZSsAz6MUH18HCErizA6JShR6ZWkDMqoVF9UX1RfUl9SX1JfUl9SX1JfUl9SX1JfUl9WX1ZfVl9WX1ZfVl9WX1ZfVl9WX1FfUV9RX1FfUV9RX1FfUV9RX1EfOGcBLKAFb4EsBAvRQrKQLZgZzAxmBjODmcHMYGYwc50TUGrI9Y2lhqKhzgwJYAEteAtkIViIFpIFM6OZvZm9meuMQaihmrEGshAsRAvJQjX7GqqZ6rR3FsACWvAWqrkuFXUu4bZYVHNdor6GdRoO86hv4Of7cnx5Ib/9udoee2W/rpfjeLqvY13Ktn28uP0F", + "bytecode": "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", + "debug_symbols": "pdfLTuNAEAXQf/E6C1d3VT/4ldEImWBQJCuJTII0Qvz7VLvqMrCYTXvje/OoQ+fRNvkYnuen++vj6fxyeRsefn0MT+tpWU6vj8vlON1Ol7Pe+/F5GHDz8bbOs941fHtcp67TOp9vw8P5viyH4X1a7tuT3q7TecvbtOqj42GYz8+aCr6clrm1z8O/6fH/oxSiD1MoX+PSM8+5Zz4x5lPdN1961h9G8flA47750LP+wAnzQvvmc9f6S8Z8DbvmI/WsP4aCee5Zf5Svv5/CvvnStf6K9fMY982HnvVzrJhn3jefetbPBScfLmnXvIw98/J1/pGu/fdtnrvmE/afZNo3X3u+/2nE9zdR3Dcfu+YFn1/KPz+/33prOp7WH1e8Iegp4zBE/eAPA+sTD4Nsx7Qd83Ys27FuRxotyCJY6Ly+baSArp7EIllki2JRtwijBVkEi2hhSjAlmBJMCaYEU6IqulujKrppYrCIFmwhFskiWxSLugWPFqawKWwKm8KmsCmsCum7zMoQadZ22dU3TiHSb69Qu/hqKkXtDY3tsqjJnuKpHOnLkObp65DiWS3T6EmewTN6sqd4Jk/3knvJvexedi+7l93L7mX3snvZvexedq+4V9wr7hX3invFveJeca+4V9yr7lX3qnvVvepeda+6V92r7lX3aBxRCCWgRBRGEZSEklEKCmSCTJAJMkEmyAS57QiqreT2j0orBaV6aTvDCqEElIjCKIKSUCAHyAFyhBwhR8gRcoQcIUfIEXKEHCEzZIbMkBkyQ2bIDJkhM2SGLJAFskAWyAJZIAtkgSyQBXKCnCAnyAlygpwgJ8gJcoKcILdtFqiVJodWAkpEYRRBaXJspcncSkGpXtqGs0IoTW4n4LbnQjsFt00X2on/fVpP09My+++al/v5+O1nzu3PFY/gh9B1vRzn5/s6twvE9pheMv4C", "file_map": { "50": { "source": "fn main(x: u128, y: u128, z: u8) {\n let const_x = 12345;\n let const_y = 2345678;\n let const_z = 2;\n\n assert_eq(x + y, const_x + const_y);\n assert_eq(y - x, const_y - const_x);\n assert_eq(x * y, const_x * const_y);\n assert_eq(y / x, const_y / const_x);\n assert_eq(y % x, const_y % const_x);\n assert_eq(!x, !const_x);\n assert_eq(x ^ y, const_x ^ const_y);\n assert_eq(x & y, const_x & const_y);\n assert_eq(x | y, const_x | const_y);\n assert_eq(x >> z, const_x >> const_z);\n assert_eq(x << z, const_x << const_z);\n assert_eq(x < y, const_x < const_y);\n assert_eq(x <= y, const_x <= const_y);\n assert_eq(x != y, const_x != const_y);\n assert_eq(y > x, const_y > const_x);\n assert_eq(y >= x, const_y >= const_x);\n}\n",