Support emission of loops in Adaptive_RIFLA

This change adds logic to support emission of loops into QIR when use the `Adaptive_RIFLA` profile. The strategy employed uses changes to both RCA and Partial Evaluation to accomplish this.

In RCA, we add a new check that identifies loops whose condition is marked as static and speculatively marks them as dynamic to compute what capabilities they would require at runtime. If the resulting capabilities are compatible with the current target, the loop remains dynamic, otherwise the RCA state is reset and the loop is marked as the originally analyzed static.

In Partial Evaluation, new support for dynamic loops is added, where a loop marked as dynamic is emitted as a sequence of blocks with appropriate backward branches to capture the while-loop structure.

This change includes new unit tests to verify analysis and emission of loop structures into RIR and new integration tests to verify the whole program stucture and execution of QIR v2 with loops via qir-runner.

Author: swernli

source/compiler/qsc/benches/rca.rs

@@ -92,7 +92,7 @@ impl CompilationContext {
     }
 
     fn analyze_all(&mut self) {
-        let analyzer = Analyzer::init(&self.fir_store);
+        let analyzer = Analyzer::init(&self.fir_store, TargetCapabilityFlags::all());
         let compute_properties = analyzer.analyze_all();
         self.compute_properties = Some(compute_properties);
     }
@@ -108,8 +108,11 @@ impl CompilationContext {
         package_compute_properties.clear();
 
         // Analyze the open package without re-analyzing the other packages.
-        let analyzer =
-            Analyzer::init_with_compute_properties(&self.fir_store, compute_properties.clone());
+        let analyzer = Analyzer::init_with_compute_properties(
+            &self.fir_store,
+            TargetCapabilityFlags::all(),
+            compute_properties.clone(),
+        );
         self.compute_properties = Some(analyzer.analyze_package(open_package_id));
     }
 

source/compiler/qsc_codegen/src/qir.rs

@@ -65,7 +65,7 @@ pub fn fir_to_qir_from_callable(
     args: Value,
 ) -> Result<String, qsc_partial_eval::Error> {
     let compute_properties = compute_properties.unwrap_or_else(|| {
-        let analyzer = qsc_rca::Analyzer::init(fir_store);
+        let analyzer = qsc_rca::Analyzer::init(fir_store, capabilities);
         analyzer.analyze_all()
     });
 
@@ -97,7 +97,7 @@ pub fn fir_to_rir_from_callable(
     partial_eval_config: PartialEvalConfig,
 ) -> Result<(Program, Program), qsc_partial_eval::Error> {
     let compute_properties = compute_properties.unwrap_or_else(|| {
-        let analyzer = qsc_rca::Analyzer::init(fir_store);
+        let analyzer = qsc_rca::Analyzer::init(fir_store, capabilities);
         analyzer.analyze_all()
     });
 
@@ -122,7 +122,7 @@ fn get_rir_from_compilation(
     partial_eval_config: PartialEvalConfig,
 ) -> Result<rir::Program, qsc_partial_eval::Error> {
     let compute_properties = compute_properties.unwrap_or_else(|| {
-        let analyzer = qsc_rca::Analyzer::init(fir_store);
+        let analyzer = qsc_rca::Analyzer::init(fir_store, capabilities);
         analyzer.analyze_all()
     });
 

source/compiler/qsc_partial_eval/src/lib.rs

@@ -2315,11 +2315,18 @@ impl<'a> PartialEvaluator<'a> {
                     .get_current_scope()
                     .get_hybrid_local_value(*local_var_id);
 
-                // Check whether the bound value is a mutable variable, and if so, return its value directly rather than
-                // the variable if it is static at this moment.
+                // Check whether the bound value is a mutable variable and we are not currently evaluating a branch.
+                // If so, return its value directly rather than the variable if it is static at this moment.
                 if let Value::Var(var) = bound_value {
                     let current_scope = self.eval_context.get_current_scope();
-                    if let Some(literal) = current_scope.get_static_value(var.id.into()) {
+                    if let Some(literal) = current_scope.get_static_value(var.id.into())
+                        && (!current_scope.is_currently_evaluating_branch()
+                            || !self
+                                .program
+                                .config
+                                .capabilities
+                                .contains(TargetCapabilityFlags::BackwardsBranching))
+                    {
                         map_rir_literal_to_eval_value(*literal)
                     } else {
                         bound_value.clone()
@@ -2337,6 +2344,18 @@ impl<'a> PartialEvaluator<'a> {
         condition_expr_id: ExprId,
         body_block_id: BlockId,
     ) -> Result<EvalControlFlow, Error> {
+        if self
+            .program
+            .config
+            .capabilities
+            .contains(TargetCapabilityFlags::BackwardsBranching)
+            && !self.is_static_expr(condition_expr_id)
+        {
+            // If backwards branching is supported and the loop condition is not static,
+            // we can generate a while loop structure in RIR without unrolling the loop.
+            return self.eval_expr_emit_while(loop_expr_id, condition_expr_id, body_block_id);
+        }
+
         // Verify assumptions: the condition expression must either static (such that it can be fully evaluated) or
         // dynamic but constant at runtime (such that it can be partially evaluated to a known value).
         assert!(
@@ -2393,6 +2412,89 @@ impl<'a> PartialEvaluator<'a> {
         Ok(EvalControlFlow::Continue(Value::unit()))
     }
 
+    fn eval_expr_emit_while(
+        &mut self,
+        loop_expr_id: ExprId,
+        condition_expr_id: ExprId,
+        body_block_id: BlockId,
+    ) -> Result<EvalControlFlow, Error> {
+        // Pop the current block node and create the necessary block nodes for the loop structure.
+        let current_block_node = self.eval_context.pop_block_node();
+        let conditional_block_node_id = self.create_program_block();
+        let conditional_block_node = BlockNode {
+            id: conditional_block_node_id,
+            successor: current_block_node.successor,
+        };
+        let continuation_block_node_id = self.create_program_block();
+        let continuation_block_node = BlockNode {
+            id: continuation_block_node_id,
+            successor: current_block_node.successor,
+        };
+        self.eval_context.push_block_node(continuation_block_node);
+
+        // Insert the jump instruction to the conditional block from the current block.
+        let jump_to_condition_ins = Instruction::Jump(conditional_block_node_id);
+        self.get_program_block_mut(current_block_node.id)
+            .0
+            .push(jump_to_condition_ins);
+
+        // In the conditional block, evaluate the condition expression and generate the branch instruction.
+        self.eval_context.push_block_node(conditional_block_node);
+        let condition_control_flow = self.try_eval_expr(condition_expr_id)?;
+        if condition_control_flow.is_return() {
+            return Err(Error::Unexpected(
+                "embedded return in loop condition".to_string(),
+                self.get_expr_package_span(condition_expr_id),
+            ));
+        }
+        let condition_value = condition_control_flow.into_value();
+
+        if let Value::Bool(false) = condition_value {
+            // If the condition is statically false, jump directly to the continuation block.
+            let jump_to_continuation_ins = Instruction::Jump(continuation_block_node_id);
+            self.get_current_rir_block_mut()
+                .0
+                .push(jump_to_continuation_ins);
+            let _ = self.eval_context.pop_block_node();
+            return Ok(EvalControlFlow::Continue(Value::unit()));
+        }
+
+        // Otherwise, branch to either the body block or the continuation block.
+        let body_block_node_id = self.create_program_block();
+        let body_block_node = BlockNode {
+            id: body_block_node_id,
+            successor: Some(conditional_block_node_id),
+        };
+        let condition_value_var = condition_value.unwrap_var();
+        let condition_rir_var = map_eval_var_to_rir_var(condition_value_var);
+        let metadata = self.metadata_from_expr(loop_expr_id);
+        let branch_ins = Instruction::Branch(
+            condition_rir_var,
+            body_block_node_id,
+            continuation_block_node_id,
+            metadata,
+        );
+        self.get_current_rir_block_mut().0.push(branch_ins);
+        let _ = self.eval_context.pop_block_node();
+
+        // In the body block, evaluate the loop body and jump back to the conditional block.
+        self.eval_context.push_block_node(body_block_node);
+        let body_control_flow = self.try_eval_block(body_block_id)?;
+        if body_control_flow.is_return() {
+            return Err(Error::Unexpected(
+                "embedded return in loop body".to_string(),
+                self.get_expr_package_span(condition_expr_id),
+            ));
+        }
+        let jump_to_condition_ins = Instruction::Jump(conditional_block_node_id);
+        self.get_current_rir_block_mut()
+            .0
+            .push(jump_to_condition_ins);
+        let _ = self.eval_context.pop_block_node();
+
+        Ok(EvalControlFlow::Continue(Value::unit()))
+    }
+
     fn eval_result_as_bool_operand(&mut self, result: val::Result) -> Operand {
         match result {
             val::Result::Id(id) => {

source/compiler/qsc_partial_eval/src/tests.rs

@@ -67,17 +67,7 @@ pub fn assert_error(error: &Error, expected_error: &Expect) {
 
 #[must_use]
 pub fn get_partial_evaluation_error(source: &str) -> Error {
-    let maybe_program = compile_and_partially_evaluate(
-        source,
-        TargetCapabilityFlags::all(),
-        PartialEvalConfig {
-            generate_debug_metadata: false,
-        },
-    );
-    match maybe_program {
-        Ok(_) => panic!("partial evaluation succeeded"),
-        Err(error) => error,
-    }
+    get_partial_evaluation_error_with_capabilities(source, Profile::AdaptiveRIF.into())
 }
 
 #[must_use]
@@ -100,21 +90,7 @@ pub fn get_partial_evaluation_error_with_capabilities(
 
 #[must_use]
 pub fn get_rir_program(source: &str) -> Program {
-    let maybe_program = compile_and_partially_evaluate(
-        source,
-        Profile::AdaptiveRIF.into(),
-        PartialEvalConfig {
-            generate_debug_metadata: false,
-        },
-    );
-    match maybe_program {
-        Ok(program) => {
-            // Verify the program can go through transformations.
-            check_and_transform(&mut program.clone());
-            program
-        }
-        Err(error) => panic!("partial evaluation failed: {error:?}"),
-    }
+    get_rir_program_with_capabilities(source, Profile::AdaptiveRIF.into())
 }
 
 #[must_use]
@@ -242,7 +218,7 @@ impl CompilationContext {
         .expect("should be able to create a new compiler");
         let package_id = map_hir_package_to_fir(compiler.source_package_id());
         let fir_store = lower_hir_package_store(compiler.package_store());
-        let analyzer = Analyzer::init(&fir_store);
+        let analyzer = Analyzer::init(&fir_store, capabilities);
         let compute_properties = analyzer.analyze_all();
         let package = fir_store.get(package_id);
         let entry = ProgramEntry {