[CIR][CIRGen][NFC] Cleanups: more boilerplate work for conditional on exceptions

Code path still hits an assert sooner, incremental NFC step.

Author: bcardosolopes

clang/include/clang/CIR/Dialect/IR/CIRDataLayout.h

@@ -62,6 +62,10 @@ class CIRDataLayout {
     return getAlignment(ty, true);
   }
 
+  llvm::Align getPrefTypeAlign(mlir::Type Ty) const {
+    return getAlignment(Ty, false);
+  }
+
   /// Returns the maximum number of bytes that may be overwritten by
   /// storing the specified type.
   ///

clang/lib/CIR/CodeGen/CIRGenCleanup.cpp

@@ -115,6 +115,75 @@ RValue DominatingValue<RValue>::saved_type::restore(CIRGenFunction &CGF) {
   llvm_unreachable("bad saved r-value kind");
 }
 
+static bool IsUsedAsEHCleanup(EHScopeStack &EHStack,
+                              EHScopeStack::stable_iterator cleanup) {
+  // If we needed an EH block for any reason, that counts.
+  if (EHStack.find(cleanup)->hasEHBranches())
+    return true;
+
+  // Check whether any enclosed cleanups were needed.
+  for (EHScopeStack::stable_iterator i = EHStack.getInnermostEHScope();
+       i != cleanup;) {
+    assert(cleanup.strictlyEncloses(i));
+
+    EHScope &scope = *EHStack.find(i);
+    if (scope.hasEHBranches())
+      return true;
+
+    i = scope.getEnclosingEHScope();
+  }
+
+  return false;
+}
+
+enum ForActivation_t { ForActivation, ForDeactivation };
+
+/// The given cleanup block is changing activation state.  Configure a
+/// cleanup variable if necessary.
+///
+/// It would be good if we had some way of determining if there were
+/// extra uses *after* the change-over point.
+static void setupCleanupBlockActivation(CIRGenFunction &CGF,
+                                        EHScopeStack::stable_iterator C,
+                                        ForActivation_t kind,
+                                        mlir::Operation *dominatingIP) {
+  EHCleanupScope &Scope = cast<EHCleanupScope>(*CGF.EHStack.find(C));
+
+  // We always need the flag if we're activating the cleanup in a
+  // conditional context, because we have to assume that the current
+  // location doesn't necessarily dominate the cleanup's code.
+  bool isActivatedInConditional =
+      (kind == ForActivation && CGF.isInConditionalBranch());
+
+  bool needFlag = false;
+
+  // Calculate whether the cleanup was used:
+
+  //   - as a normal cleanup
+  if (Scope.isNormalCleanup()) {
+    Scope.setTestFlagInNormalCleanup();
+    needFlag = true;
+  }
+
+  //  - as an EH cleanup
+  if (Scope.isEHCleanup() &&
+      (isActivatedInConditional || IsUsedAsEHCleanup(CGF.EHStack, C))) {
+    Scope.setTestFlagInEHCleanup();
+    needFlag = true;
+  }
+
+  // If it hasn't yet been used as either, we're done.
+  if (!needFlag)
+    return;
+
+  Address var = Scope.getActiveFlag();
+  if (!var.isValid()) {
+    llvm_unreachable("NYI");
+  }
+
+  llvm_unreachable("NYI");
+}
+
 /// Deactive a cleanup that was created in an active state.
 void CIRGenFunction::DeactivateCleanupBlock(EHScopeStack::stable_iterator C,
                                             mlir::Operation *dominatingIP) {
@@ -143,7 +212,9 @@ void CIRGenFunction::DeactivateCleanupBlock(EHScopeStack::stable_iterator C,
     return;
   }
 
-  llvm_unreachable("NYI");
+  // Otherwise, follow the general case.
+  setupCleanupBlockActivation(*this, C, ForDeactivation, dominatingIP);
+  Scope.setActive(false);
 }
 
 void CIRGenFunction::initFullExprCleanupWithFlag(Address ActiveFlag) {

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -2307,15 +2307,57 @@ struct DominatingCIRValue {
   typedef llvm::PointerIntPair<mlir::Value, 1, bool> saved_type;
 
   /// Answer whether the given value needs extra work to be saved.
-  static bool needsSaving(mlir::Value value) { llvm_unreachable("NYI"); }
+  static bool needsSaving(mlir::Value value) {
+    if (!value)
+      return false;
+
+    // If it's a block argument, we don't need to save.
+    mlir::Operation *definingOp = value.getDefiningOp();
+    if (!definingOp)
+      return false;
+
+    // If value is defined the function or a global init entry block, we don't
+    // need to save.
+    mlir::Block *currBlock = definingOp->getBlock();
+    if (!currBlock->isEntryBlock() || !definingOp->getParentOp())
+      return false;
+
+    if (auto fnOp = definingOp->getParentOfType<mlir::cir::FuncOp>()) {
+      if (&fnOp.getBody().front() == currBlock)
+        return true;
+      return false;
+    }
+
+    if (auto globalOp = definingOp->getParentOfType<mlir::cir::GlobalOp>()) {
+      assert(globalOp.getNumRegions() == 2 && "other regions NYI");
+      if (&globalOp.getCtorRegion().front() == currBlock)
+        return true;
+      if (&globalOp.getDtorRegion().front() == currBlock)
+        return true;
+      return false;
+    }
+
+    return false;
+  }
 
   static saved_type save(CIRGenFunction &CGF, mlir::Value value);
   static mlir::Value restore(CIRGenFunction &CGF, saved_type value);
 };
 
 inline DominatingCIRValue::saved_type
 DominatingCIRValue::save(CIRGenFunction &CGF, mlir::Value value) {
-  llvm_unreachable("NYI");
+  if (!needsSaving(value))
+    return saved_type(value, false);
+
+  // Otherwise, we need an alloca.
+  auto align = CharUnits::fromQuantity(
+      CGF.CGM.getDataLayout().getPrefTypeAlign(value.getType()));
+  mlir::Location loc = value.getLoc();
+  Address alloca =
+      CGF.CreateTempAlloca(value.getType(), align, loc, "cond-cleanup.save");
+  CGF.getBuilder().createStore(loc, value, alloca);
+
+  return saved_type(alloca.emitRawPointer(), true);
 }
 
 inline mlir::Value DominatingCIRValue::restore(CIRGenFunction &CGF,