Function process_block_instructions

src/optimise1/dataflow.rs:140–1376

Helper to simulate block execution for dataflow analysis OR transformation When used for analysis, it just calculates the output state. When used for transformation, it produces new instructions.

(
    info: &BasicBlockInfo,
    initial_state: &ConstantMap,
    transform: bool, // If true, generate new instructions; otherwise, just calculate state
    _data_types: &HashMap<String, DataType>, /

                let mut simplified_algebraically = false;

                if is_zero(&new_op2) {
                    // a + 0 = a
                    optimised_instruction = Instruction::Move {
                        dest: dest.clone(),
                        src: new_op1.clone(),
                    };
                    update_state_based_on_operand(
                        &mut current_state,
                        dest,
                        &new_op1,
                        initial_state,
                    );
                    simplified_algebraically = true;
                } else if is_zero(&new_op1) {
                    // 0 + a = a
                    optimised_instruction = Instruction::Move {
                        dest: dest.clone(),
                        src: new_op2.clone(),
                    };
                    update_state_based_on_operand(
                        &mut current_state,
                        dest,
                        &new_op2,
                        initial_state,
                    );
                    simplified_algebraically = true;
                }

                if !simplified_algebraically && let (Some(c1), Some(c2)) = (const1, const2) {
                    if let Some(result_const) = interpret::add_constants(c1, c2) {
                        current_state.insert(dest.clone(), result_const.clone());
                        // If transforming, replace Add with Move constant
                        if transform {
                            optimised_instruction = Instruction::Move {
                                dest: dest.clone(),
                                src: Operand::Constant(result_const),
                            };
                        } else {
                            keep_original_instruction = false;
                        }
                    } else {
                        // Calculation failed -> result not constant
                        current_state.remove(dest);
                    }
                } else if !simplified_algebraically {
                    // Operands not both constant, and no simplification -> result is not constant
                    current_state.remove(dest);
                }
                // If simplified_algebraically, state already updated, instruction is Move
            }

            Instruction::Sub { dest, op1, op2 } => {
                let const1 = lookup_const(op1, &current_state);
                let const2 = lookup_const(op2, &current_state);
                let new_op1 = const1.clone().map_or(op1.clone(), Operand::Constant);
                let new_op2 = const2.clone().map_or(op2.clone(), Operand::Constant);