[CIR] Add emitNullConstant support for records

This includes member data attribute in to enable and existing test.
LLVM lowering is follow up work.

Fixes XFAIL in ../clang/test/CIR/CodeGen/nonzeroinit-struct.cpp

Author: bcardosolopes

clang/lib/CIR/CodeGen/CIRGenCXXABI.cpp

@@ -86,6 +86,10 @@ bool CIRGenCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
   return true;
 }
 
+mlir::TypedAttr CIRGenCXXABI::emitNullMemberPointer(clang::QualType T) {
+  llvm_unreachable("NYI");
+}
+
 CharUnits CIRGenCXXABI::getArrayCookieSize(const CXXNewExpr *E) {
   if (!requiresArrayCookie(E))
     return CharUnits::Zero();

clang/lib/CIR/CodeGen/CIRGenCXXABI.h

@@ -292,6 +292,9 @@ class CIRGenCXXABI {
     return true;
   }
 
+  /// Create a null member pointer of the given type.
+  virtual mlir::TypedAttr emitNullMemberPointer(clang::QualType T);
+
   /// Gets the offsets of all the virtual base pointers in a given class.
   virtual std::vector<CharUnits> getVBPtrOffsets(const CXXRecordDecl *RD);
 

clang/lib/CIR/CodeGen/CIRGenExprConst.cpp

@@ -1733,20 +1733,21 @@ static mlir::TypedAttr emitNullConstant(CIRGenModule &CGM, const RecordDecl *rd,
   }
 
   // Fill in all the fields.
-  for (const auto *Field : rd->fields()) {
+  for (const auto *field : rd->fields()) {
     // Fill in non-bitfields. (Bitfields always use a zero pattern, which we
     // will fill in later.)
-    if (!Field->isBitField() &&
-        !isEmptyFieldForLayout(CGM.getASTContext(), Field)) {
-      llvm_unreachable("NYI");
+    if (!field->isBitField() &&
+        !isEmptyFieldForLayout(CGM.getASTContext(), field)) {
+      unsigned fieldIndex = layout.getCIRFieldNo(field);
+      elements[fieldIndex] = CGM.emitNullConstant(field->getType());
     }
 
     // For unions, stop after the first named field.
     if (rd->isUnion()) {
-      if (Field->getIdentifier())
+      if (field->getIdentifier())
         break;
-      if (const auto *FieldRD = Field->getType()->getAsRecordDecl())
-        if (FieldRD->findFirstNamedDataMember())
+      if (const auto *fieldRD = field->getType()->getAsRecordDecl())
+        if (fieldRD->findFirstNamedDataMember())
           break;
     }
   }
@@ -1780,27 +1781,8 @@ mlir::Attribute ConstantEmitter::tryEmitPrivateForVarInit(const VarDecl &D) {
       if (const CXXConstructExpr *E =
               dyn_cast_or_null<CXXConstructExpr>(D.getInit())) {
         const CXXConstructorDecl *CD = E->getConstructor();
-        // FIXME: we should probably model this more closely to C++ than
-        // just emitting a global with zero init (mimic what we do for trivial
-        // assignments and whatnots). Since this is for globals shouldn't
-        // be a problem for the near future.
-        if (CD->isTrivial() && CD->isDefaultConstructor()) {
-          const auto *cxxrd =
-              cast<CXXRecordDecl>(Ty->getAs<RecordType>()->getDecl());
-          // Some cases, such as member pointer members, can't be zero
-          // initialized. These are "zero-initialized" in the language standard
-          // sense, but the target ABI may require that a literal value other
-          // than zero be used in the initializer to make clear that a pointer
-          // with the value zero is not what is intended. The classic codegen
-          // goes through emitNullConstant for those cases but generates a
-          // non-zero constant. We can't quite do that here because we need an
-          // attribute and not a value, but something like that can be
-          // implemented.
-          if (!CGM.getTypes().isZeroInitializable(cxxrd)) {
-            llvm_unreachable("NYI");
-          }
-          return cir::ZeroAttr::get(CGM.convertType(D.getType()));
-        }
+        if (CD->isTrivial() && CD->isDefaultConstructor())
+          return CGM.emitNullConstant(D.getType());
       }
     }
   }
@@ -1820,8 +1802,11 @@ mlir::Attribute ConstantEmitter::tryEmitPrivateForVarInit(const VarDecl &D) {
 
   // Try to emit the initializer.  Note that this can allow some things that
   // are not allowed by tryEmitPrivateForMemory alone.
-  if (auto value = D.evaluateValue())
+  if (auto value = D.evaluateValue()) {
+    assert(!value->allowConstexprUnknown() &&
+           "Constexpr unknown values are not allowed in CodeGen");
     return tryEmitPrivateForMemory(*value, destType);
+  }
 
   return nullptr;
 }
@@ -2109,14 +2094,14 @@ mlir::TypedAttr CIRGenModule::emitNullConstant(QualType T) {
     llvm_unreachable("NYI");
   }
 
-  if (T->getAs<clang::RecordType>())
-    llvm_unreachable("NYI");
+  if (const RecordType *rt = T->getAs<RecordType>())
+    return ::emitNullConstant(*this, rt->getDecl(), /*complete object*/
+                              true);
 
   assert(T->isMemberDataPointerType() &&
          "Should only see pointers to data members here!");
 
-  llvm_unreachable("NYI");
-  return {};
+  return getCXXABI().emitNullMemberPointer(T);
 }
 
 mlir::Value CIRGenModule::emitMemberPointerConstant(const UnaryOperator *E) {

clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp

@@ -123,6 +123,7 @@ class CIRGenItaniumCXXABI : public CIRGenCXXABI {
 
   bool classifyReturnType(CIRGenFunctionInfo &FI) const override;
   bool isZeroInitializable(const MemberPointerType *MPT) override;
+  mlir::TypedAttr emitNullMemberPointer(clang::QualType T) override;
 
   AddedStructorArgCounts
   buildStructorSignature(GlobalDecl GD,
@@ -2749,6 +2750,21 @@ bool CIRGenItaniumCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
   return MPT->isMemberFunctionPointer();
 }
 
+mlir::TypedAttr CIRGenItaniumCXXABI::emitNullMemberPointer(clang::QualType T) {
+  auto *MPT = T->getAs<MemberPointerType>();
+  // Itanium C++ ABI 2.3:
+  //   A NULL pointer is represented as -1.
+  //
+  // Note that CIR uses a DataMemberAttr without member_index to get
+  // #cir.data_member<null>, lowering shall later transform it into -1.
+  if (MPT->isMemberDataPointer())
+    return cir::DataMemberAttr::get(
+        cast<cir::DataMemberType>(CGM.convertType(T)));
+
+  // Create an annon struct with two constant int of CGM.PtrDiffTy size.
+  llvm_unreachable("NYI");
+}
+
 /// The Itanium ABI always places an offset to the complete object
 /// at entry -2 in the vtable.
 void CIRGenItaniumCXXABI::emitVirtualObjectDelete(

clang/test/CIR/CodeGen/nonzeroinit-struct.cpp

@@ -1,22 +1,23 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
 // RUN: FileCheck --input-file=%t.cir %s
 
-// This case is not yet implemented.
-// XFAIL: *
+// TODO: Lower #cir.data_member<null> to -1 for LLVM (in the itanium ABI context).
+// RUN-DISABLE: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
+// RUN-DISABLE: FileCheck --input-file=%t.ll -check-prefix=LLVM %s
 
 struct Other {
-    int x;
+  int x;
 };
 
 struct Trivial {
-    int x;
-    double y;
-    decltype(&Other::x) ptr;
+  int x;
+  double y;
+  decltype(&Other::x) ptr;
 };
 
 // This case has a trivial default constructor, but can't be zero-initialized.
 Trivial t;
 
-// The type is wrong on the last member here. It needs to be initialized to -1,
-//   but I don't know what that will look like.
-// CHECK: cir.global {{.*}} @t = #cir.const_record<{#cir.int<0> : !s32i, #cir.fp<0.000000e+00> : !cir.double, #cir.int<-1> : !s64i}>
+// CHECK: !rec_Trivial = !cir.record<struct "Trivial" {!s32i, !cir.double, !cir.data_member<!s32i in !rec_Other>} #cir.record.decl.ast>
+// CHECK: cir.global external @t = #cir.const_record<{#cir.int<0> : !s32i, #cir.fp<0.000000e+00> : !cir.double,
+// CHECK-SAME: #cir.data_member<null> : !cir.data_member<!s32i in !rec_Other>}> : !rec_Trivial