use entry_points[0] not brillig_function_id

noir-lang · vezenovm · Feb 18, 2025 · Jan 28, 2025 · Jan 28, 2025 · Jan 28, 2025
commit 2e5e5d71fb95c9c1ca1f4e3ead1df8570552c922
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_globals.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_globals.rs
@@ -270,7 +270,7 @@ impl BrilligGlobals {
             // Thus, if a call can be used by two entry points we should not use the hoisted constant allocations.
             if entry_points.len() == 1 {
                 let hoisted_allocations =
-                    self.entry_point_hoisted_globals_map.get(&brillig_function_id);
+                    self.entry_point_hoisted_globals_map.get(&entry_points[0]);
                 let hoisted_allocations = hoisted_allocations.unwrap_or_else(|| panic!("ICE: Expected hoisted allocations to be set for function {brillig_function_id}"));
                 hoisted_constants_allocations.extend(hoisted_allocations);
             }

diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs
        }

        for (i, bit_size) in arguments.iter().flat_map(flat_bit_sizes).enumerate() {
            // Calldatacopy tags everything with field type, so when downcast when necessary
            if bit_size < F::max_num_bits() {
                self.cast_instruction(
                    SingleAddrVariable::new(
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs
            // These can fail.
            Constrain(..) | ConstrainNotEqual(..) | RangeCheck { .. } => true,

            // This should never be side-effectful
            MakeArray { .. } | Noop => false,

            // Some binary math can overflow or underflow
diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs
    Or,
    /// Bitwise xor (^)
    Xor,
    /// Bitshift left (<<)
    Shl,
    /// Bitshift right (>>)
    Shr,
 }

        }

        let operator = if lhs_type == NumericType::NativeField {
            // Unchecked operations between fields or bools don't make sense, so we convert those to non-unchecked
            // to reduce noise and confusion in the generated SSA.
            match operator {
                BinaryOp::Add { unchecked: true } => BinaryOp::Add { unchecked: false },
                _ => operator,
            }
        } else if lhs_type == NumericType::bool() {
            // Unchecked mul between bools doesn't make sense, so we convert that to non-unchecked
            if let BinaryOp::Mul { unchecked: true } = operator {
                BinaryOp::Mul { unchecked: false }
            } else {
                        Instruction::binary(BinaryOp::Mul { unchecked: true }, lhs, rhs);
                    return SimplifyResult::SimplifiedToInstruction(instruction);
                }
                if lhs_type.is_unsigned() {
                    // It's common in other programming languages to truncate values to a certain bit size using
                    // a bitwise AND with a bit mask. However this operation is quite inefficient inside a snark.
                    //
diff --git a/compiler/noirc_evaluator/src/ssa/opt/pure.rs b/compiler/noirc_evaluator/src/ssa/opt/pure.rs
        // Set of functions we call which the purity result depends on.
        // `is_pure` is intended to be called on each function, building
        // up a call graph of sorts to check afterwards to propagate impurity
        // from called functions to their callers. Resultingly, an initial "Pure"
        // result here could be overridden by one of these dependencies being impure.
        let mut dependencies = BTreeSet::new();

diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs
    use super::{is_new_size_ok, BoilerplateStats, Loops};

    /// Tries to unroll all loops in each SSA function once, calling the `Function` directly,
    /// bypassing the iterative loop done by the SSA which does further optimisations.
    ///
    /// If any loop cannot be unrolled, it is left as-is or in a partially unrolled state.
    fn try_unroll_loops(mut ssa: Ssa) -> (Ssa, Vec<RuntimeError>) {
diff --git a/compiler/noirc_frontend/src/parser/parser/expression.rs b/compiler/noirc_frontend/src/parser/parser/expression.rs
    ///     = bool
    ///     | int
    ///     | str
    ///     | rawstr
    ///     | fmtstr
    ///     | QuoteExpression
    ///     | ArrayExpression
	}

	for (i, bit_size) in arguments.iter().flat_map(flat_bit_sizes).enumerate() {
	// Calldatacopy tags everything with field type, so when downcast when necessary
Check warning on line 182 in compiler/noirc_evaluator/src/brillig/brillig_ir/entry_point.rs GitHub Actions / Code `Unknown word (Calldatacopy)`
	if bit_size < F::max_num_bits() {
	self.cast_instruction(
	SingleAddrVariable::new(
	// These can fail.
	Constrain(..) \| ConstrainNotEqual(..) \| RangeCheck { .. } => true,

	// This should never be side-effectful
Check warning on line 426 in compiler/noirc_evaluator/src/ssa/ir/instruction.rs GitHub Actions / Code `Unknown word (effectful)`
	MakeArray { .. } \| Noop => false,

	// Some binary math can overflow or underflow
	Or,
	/// Bitwise xor (^)
	Xor,
	/// Bitshift left (<<)
Check warning on line 42 in compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs GitHub Actions / Code `Unknown word (Bitshift)`
	Shl,
	/// Bitshift right (>>)
Check warning on line 44 in compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs GitHub Actions / Code `Unknown word (Bitshift)`
	Shr,
	}

	}

	let operator = if lhs_type == NumericType::NativeField {
	// Unchecked operations between fields or bools don't make sense, so we convert those to non-unchecked
Check warning on line 110 in compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs GitHub Actions / Code `Unknown word (bools)`
	// to reduce noise and confusion in the generated SSA.
	match operator {
	BinaryOp::Add { unchecked: true } => BinaryOp::Add { unchecked: false },
	_ => operator,
	}
	} else if lhs_type == NumericType::bool() {
	// Unchecked mul between bools doesn't make sense, so we convert that to non-unchecked
Check warning on line 119 in compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs GitHub Actions / Code `Unknown word (bools)`
	if let BinaryOp::Mul { unchecked: true } = operator {
	BinaryOp::Mul { unchecked: false }
	} else {
	Instruction::binary(BinaryOp::Mul { unchecked: true }, lhs, rhs);
	return SimplifyResult::SimplifiedToInstruction(instruction);
	}
	if lhs_type.is_unsigned() {
Check warning on line 292 in compiler/noirc_evaluator/src/ssa/ir/instruction/binary.rs GitHub Actions / Code `Unknown word (bools)`
	// It's common in other programming languages to truncate values to a certain bit size using
	// a bitwise AND with a bit mask. However this operation is quite inefficient inside a snark.
	//
	// Set of functions we call which the purity result depends on.
	// `is_pure` is intended to be called on each function, building
	// up a call graph of sorts to check afterwards to propagate impurity
	// from called functions to their callers. Resultingly, an initial "Pure"
Check warning on line 116 in compiler/noirc_evaluator/src/ssa/opt/pure.rs GitHub Actions / Code `Unknown word (Resultingly)`
	// result here could be overridden by one of these dependencies being impure.
	let mut dependencies = BTreeSet::new();
	use super::{is_new_size_ok, BoilerplateStats, Loops};

	/// Tries to unroll all loops in each SSA function once, calling the `Function` directly,
	/// bypassing the iterative loop done by the SSA which does further optimisations.
Check warning on line 1070 in compiler/noirc_evaluator/src/ssa/opt/unrolling.rs GitHub Actions / Code `Unknown word (optimisations)`
	///
	/// If any loop cannot be unrolled, it is left as-is or in a partially unrolled state.
	fn try_unroll_loops(mut ssa: Ssa) -> (Ssa, Vec<RuntimeError>) {
	/// = bool
	/// \| int
	/// \| str
	/// \| rawstr
Check warning on line 604 in compiler/noirc_frontend/src/parser/parser/expression.rs GitHub Actions / Code `Unknown word (rawstr)`
	/// \| fmtstr
	/// \| QuoteExpression
	/// \| ArrayExpression