Change signature of EmitAutoVarInit to not take variable, store state

inside AutoVarEmission instead.

Author: erichkeane

clang/lib/CIR/CodeGen/CIRGenDecl.cpp

@@ -77,7 +77,7 @@ bool CIRGenFunction::isTrivialInitializer(const Expr *init) {
 }
 
 void CIRGenFunction::emitAutoVarInit(
-    const CIRGenFunction::AutoVarEmission &emission, bool allocatedSeparately) {
+    const CIRGenFunction::AutoVarEmission &emission) {
   assert(emission.Variable && "emission was not valid!");
 
   // If this was emitted as a global constant, we're done.
@@ -154,16 +154,19 @@ void CIRGenFunction::emitAutoVarInit(
     initializeWhatIsTechnicallyUninitialized(addr);
     LValue lv = makeAddrLValue(addr, type, AlignmentSource::Decl);
     emitExprAsInit(init, &d, lv);
-    // In case lv has uses it means we indeed initialized something
-    // out of it while trying to build the expression, mark it as such.
-    mlir::Value val = lv.getAddress().getPointer();
-    assert(val && "Should have an address");
-    auto allocaOp = val.getDefiningOp<cir::AllocaOp>();
-    assert((allocatedSeparately || allocaOp) &&
-           "Address should come straight out of the alloca");
-
-    if (allocaOp && !allocaOp.use_empty())
-      allocaOp.setInitAttr(mlir::UnitAttr::get(&getMLIRContext()));
+
+    if (!emission.wasEmittedAsOffloadClause()) {
+      // In case lv has uses it means we indeed initialized something
+      // out of it while trying to build the expression, mark it as such.
+      mlir::Value val = lv.getAddress().getPointer();
+      assert(val && "Should have an address");
+      auto allocaOp = val.getDefiningOp<cir::AllocaOp>();
+      assert(allocaOp && "Address should come straight out of the alloca");
+
+      if (!allocaOp.use_empty())
+        allocaOp.setInitAttr(mlir::UnitAttr::get(&getMLIRContext()));
+    }
+
     return;
   }
 

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -470,6 +470,10 @@ class CIRGenFunction : public CIRGenTypeCache {
     /// escaping block.
     bool IsEscapingByRef = false;
 
+    /// True if the variable was emitted as an offload recipe, and thus doesn't
+    /// have the same sort of alloca initialization.
+    bool EmittedAsOffload = false;
+
     mlir::Value NRVOFlag{};
 
     struct Invalid {};
@@ -482,6 +486,8 @@ class CIRGenFunction : public CIRGenTypeCache {
 
     bool wasEmittedAsGlobal() const { return !Addr.isValid(); }
 
+    bool wasEmittedAsOffloadClause() const { return EmittedAsOffload; }
+
     /// Returns the raw, allocated address, which is not necessarily
     /// the address of the object itself. It is casted to default
     /// address space for address space agnostic languages.
@@ -978,8 +984,7 @@ class CIRGenFunction : public CIRGenTypeCache {
   /// emission is not directly an alloca), the allocatedSeparately parameter can
   /// be used to suppress the assertions.  However, this should only be used in
   /// extreme cases, as it doesn't properly reflect the language/AST.
-  void emitAutoVarInit(const AutoVarEmission &emission,
-                       bool allocatedSeparately = false);
+  void emitAutoVarInit(const AutoVarEmission &emission);
   void emitAutoVarTypeCleanup(const AutoVarEmission &emission,
                               clang::QualType::DestructionKind dtorKind);
 

clang/lib/CIR/CodeGen/CIRGenOpenACCClause.cpp

@@ -407,12 +407,13 @@ class OpenACCClauseCIREmitter final
     // that instead of the variable in the other block.
     tempDeclEmission.setAllocatedAddress(
         Address{toArg, elementTy, cgf.getContext().getDeclAlign(varRecipe)});
+    tempDeclEmission.EmittedAsOffload = true;
 
     cgf.setAddrOfLocalVar(
         temporary,
         Address{fromArg, elementTy, cgf.getContext().getDeclAlign(varRecipe)});
 
-    cgf.emitAutoVarInit(tempDeclEmission, /*allocatedSeparately=*/true);
+    cgf.emitAutoVarInit(tempDeclEmission);
     mlir::acc::YieldOp::create(builder, locEnd);
   }