Address review feedback

Author: andykaylor

clang/include/clang/CIR/MissingFeatures.h

@@ -169,6 +169,7 @@ struct MissingFeatures {
   static bool maybeHandleStaticInExternC() { return false; }
   static bool constEmitterArrayILE() { return false; }
   static bool constEmitterVectorILE() { return false; }
+  static bool needsGlobalCtorDtor() { return false; }
 
   // Missing types
   static bool dataMemberType() { return false; }

clang/lib/CIR/CodeGen/CIRGenConstantEmitter.h

@@ -31,6 +31,9 @@ class ConstantEmitter {
 private:
   bool abstract = false;
 
+#ifndef NDEBUG
+  // Variables used for asserting state consistency.
+
   /// Whether non-abstract components of the emitter have been initialized.
   bool initializedNonAbstract = false;
 
@@ -39,6 +42,7 @@ class ConstantEmitter {
 
   /// Whether the constant-emission failed.
   bool failed = false;
+#endif // NDEBUG
 
   /// Whether we're in a constant context.
   bool inConstantContext = false;
@@ -101,6 +105,7 @@ class ConstantEmitter {
   mlir::Attribute tryEmitPrivateForMemory(const APValue &value, QualType t);
 
 private:
+#ifndef NDEBUG
   void initializeNonAbstract() {
     assert(!initializedNonAbstract);
     initializedNonAbstract = true;
@@ -111,6 +116,10 @@ class ConstantEmitter {
       failed = true;
     return init;
   }
+#else
+  void initializeNonAbstract() {}
+  mlir::Attribute markIfFailed(mlir::Attribute init) { return init; }
+#endif // NDEBUG
 
   class AbstractStateRAII {
     ConstantEmitter &emitter;

clang/lib/CIR/CodeGen/CIRGenExprConstant.cpp

@@ -96,10 +96,6 @@ class ConstExprEmitter
     Expr *subExpr = e->getSubExpr();
 
     switch (e->getCastKind()) {
-    case CK_HLSLArrayRValue:
-    case CK_HLSLVectorTruncation:
-    case CK_HLSLElementwiseCast:
-    case CK_HLSLAggregateSplatCast:
     case CK_ToUnion:
     case CK_AddressSpaceConversion:
     case CK_ReinterpretMemberPointer:
@@ -181,6 +177,10 @@ class ConstExprEmitter
     case CK_IntegralToFixedPoint:
     case CK_ZeroToOCLOpaqueType:
     case CK_MatrixCast:
+    case CK_HLSLArrayRValue:
+    case CK_HLSLVectorTruncation:
+    case CK_HLSLElementwiseCast:
+    case CK_HLSLAggregateSplatCast:
       return {};
     }
     llvm_unreachable("Invalid CastKind");
@@ -220,8 +220,10 @@ class ConstExprEmitter
       return {};
     }
 
-    if (ile->getType()->isRecordType())
+    if (ile->getType()->isRecordType()) {
       cgm.errorNYI(ile->getBeginLoc(), "ConstExprEmitter: record ILE");
+      return {};
+    }
 
     if (ile->getType()->isVectorType()) {
       // If we return null here, the non-constant initializer will take care of
@@ -339,9 +341,10 @@ void ConstantEmitter::finalize(cir::GlobalOp gv) {
          "finalizing emitter that was used for abstract emission?");
   assert(!finalized && "finalizing emitter multiple times");
   assert(!gv.isDeclaration());
-
+#ifndef NDEBUG
   // Note that we might also be Failed.
   finalized = true;
+#endif // NDEBUG
 }
 
 mlir::Attribute

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -412,6 +412,23 @@ void CIRGenModule::emitGlobalVarDefinition(const clang::VarDecl *vd,
     return;
   }
 
+  // Whether the definition of the variable is available externally.
+  // If yes, we shouldn't emit the GloablCtor and GlobalDtor for the variable
+  // since this is the job for its original source.
+  bool isDefinitionAvailableExternally =
+      astContext.GetGVALinkageForVariable(vd) == GVA_AvailableExternally;
+  assert(!cir::MissingFeatures::needsGlobalCtorDtor());
+
+  // It is useless to emit the definition for an available_externally variable
+  // which can't be marked as const.
+  if (isDefinitionAvailableExternally &&
+      (!vd->hasConstantInitialization() ||
+       // TODO: Update this when we have interface to check constexpr
+       // destructor.
+       vd->needsDestruction(astContext) ||
+       !vd->getType().isConstantStorage(astContext, true, true)))
+    return;
+
   mlir::Attribute init;
   const VarDecl *initDecl;
   const Expr *initExpr = vd->getAnyInitializer(initDecl);
@@ -437,7 +454,7 @@ void CIRGenModule::emitGlobalVarDefinition(const clang::VarDecl *vd,
     init = builder.getZeroInitAttr(convertType(vd->getType()));
   } else {
     emitter.emplace(*this);
-    auto initializer = emitter->tryEmitForInitializer(*initDecl);
+    mlir::Attribute initializer = emitter->tryEmitForInitializer(*initDecl);
     if (!initializer) {
       QualType qt = initExpr->getType();
       if (vd->getType()->isReferenceType())