mcdc-coverage: Use decision context stack to handle nested decisions.

- Introduce MCDCDecisionCtx
- Use a stack of MCDCDecisionCtx to handle nested decisions

Author: RenjiSann

compiler/rustc_mir_build/src/build/coverageinfo.rs

@@ -111,6 +111,9 @@ impl BranchInfoBuilder {
         let decision_depth = mcdc_state.decision_depth;
         let (mut condition_info, decision_result) =
             mcdc_state.take_condition(true_marker, false_marker);
+        // take_condition() returns Some for decision_result when the decision stack
+        // is empty, i.e. when all the conditions of the decision were instrumented,
+        // and the decision is "complete".
         if let Some(decision) = decision_result {
             match decision.conditions_num {
                 0 => {
@@ -180,22 +183,25 @@ impl BranchInfoBuilder {
 /// This limit may be relaxed if the [upstream change](https://github.com/llvm/llvm-project/pull/82448) is merged.
 const MAX_CONDITIONS_NUM_IN_DECISION: usize = 6;
 
-struct MCDCState {
+#[derive(Default)]
+struct MCDCDecisionCtx {
     /// To construct condition evaluation tree.
     decision_stack: VecDeque<ConditionInfo>,
     processing_decision: Option<MCDCDecisionSpan>,
+}
+
+struct MCDCState {
+    decision_ctx_stack: Vec<MCDCDecisionCtx>,
+    /// To track the nesting level of boolean expressions.
     decision_depth: u16,
 }
 
 impl MCDCState {
     fn new_if_enabled(tcx: TyCtxt<'_>) -> Option<Self> {
-        tcx.sess
-            .instrument_coverage_mcdc()
-            .then(|| Self {
-                decision_stack: VecDeque::new(),
-                processing_decision: None,
-                decision_depth: 0,
-            })
+        tcx.sess.instrument_coverage_mcdc().then(|| Self {
+            decision_ctx_stack: vec![MCDCDecisionCtx::default()],
+            decision_depth: 0,
+        })
     }
 
     // At first we assign ConditionIds for each sub expression.
@@ -239,20 +245,21 @@ impl MCDCState {
     // - If the op is AND, the "false_next" of LHS and RHS should be the parent's "false_next". While "true_next" of the LHS is the RHS, the "true next" of RHS is the parent's "true_next".
     // - If the op is OR, the "true_next" of LHS and RHS should be the parent's "true_next". While "false_next" of the LHS is the RHS, the "false next" of RHS is the parent's "false_next".
     fn record_conditions(&mut self, op: LogicalOp, span: Span) {
-        let decision = match self.processing_decision.as_mut() {
+        let decision_ctx = &mut self.decision_ctx_stack[self.decision_depth as usize];
+        let decision = match decision_ctx.processing_decision.as_mut() {
             Some(decision) => {
                 decision.span = decision.span.to(span);
                 decision
             }
-            None => self.processing_decision.insert(MCDCDecisionSpan {
+            None => decision_ctx.processing_decision.insert(MCDCDecisionSpan {
                 span,
                 conditions_num: 0,
                 end_markers: vec![],
-                decision_depth: 0,
+                decision_depth: self.decision_depth,
             }),
         };
 
-        let parent_condition = self.decision_stack.pop_back().unwrap_or_default();
+        let parent_condition = decision_ctx.decision_stack.pop_back().unwrap_or_default();
         let lhs_id = if parent_condition.condition_id == ConditionId::NONE {
             decision.conditions_num += 1;
             ConditionId::from(decision.conditions_num)
@@ -292,19 +299,20 @@ impl MCDCState {
             }
         };
         // We visit expressions tree in pre-order, so place the left-hand side on the top.
-        self.decision_stack.push_back(rhs);
-        self.decision_stack.push_back(lhs);
+        decision_ctx.decision_stack.push_back(rhs);
+        decision_ctx.decision_stack.push_back(lhs);
     }
 
     fn take_condition(
         &mut self,
         true_marker: BlockMarkerId,
         false_marker: BlockMarkerId,
     ) -> (Option<ConditionInfo>, Option<MCDCDecisionSpan>) {
-        let Some(condition_info) = self.decision_stack.pop_back() else {
+        let decision_ctx = &mut self.decision_ctx_stack[self.decision_depth as usize];
+        let Some(condition_info) = decision_ctx.decision_stack.pop_back() else {
             return (None, None);
         };
-        let Some(decision) = self.processing_decision.as_mut() else {
+        let Some(decision) = decision_ctx.processing_decision.as_mut() else {
             bug!("Processing decision should have been created before any conditions are taken");
         };
         if condition_info.true_next_id == ConditionId::NONE {
@@ -314,8 +322,8 @@ impl MCDCState {
             decision.end_markers.push(false_marker);
         }
 
-        if self.decision_stack.is_empty() {
-            (Some(condition_info), self.processing_decision.take())
+        if decision_ctx.decision_stack.is_empty() {
+            (Some(condition_info), decision_ctx.processing_decision.take())
         } else {
             (Some(condition_info), None)
         }
@@ -391,6 +399,7 @@ impl Builder<'_, '_> {
         if let Some(branch_info) = self.coverage_branch_info.as_mut()
             && let Some(mcdc_state) = branch_info.mcdc_state.as_mut()
         {
+            mcdc_state.decision_ctx_stack.push(MCDCDecisionCtx::default());
             mcdc_state.decision_depth += 1;
         };
     }
@@ -399,6 +408,12 @@ impl Builder<'_, '_> {
         if let Some(branch_info) = self.coverage_branch_info.as_mut()
             && let Some(mcdc_state) = branch_info.mcdc_state.as_mut()
         {
+            #[allow(unused)]
+            let Some(MCDCDecisionCtx { decision_stack, processing_decision }) =
+                mcdc_state.decision_ctx_stack.pop()
+            else {
+                bug!("Unexpected empty Decision stack");
+            };
             mcdc_state.decision_depth -= 1;
         };
     }