[clang][Interp] Implement zero-init of record types

[tbaeder]

Summary

Unify CXXTemporaryObjectExpr and CXXConstructExpr code and zero-initialize the object if requested.

Hints on how to test this properly without creating some weird intermediate object are welcome of course. :)

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

1387

I briefly talked about this with @aaron.ballman on IRC. The current interpreter properly zero-initialized all the fields of a struct, but the un-does the initialization again (and initializes them to a APValue::Indeterminate in HandleConstructorCall::SkipToField().

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[aaron.ballman]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

1493

It looks like you're not initializing base classes or padding bits: http://eel.is/c++draft/dcl.init#general-6.2 -- we could use test coverage for both of those cases (don't forget to also test bit-fields). You should also have a test for zero init of unions.

clang/lib/AST/Interp/Descriptor.cpp

288–296

This looks pretty dangerous -- is it safe to assume the type is a constant array, or should this be a dyn_cast and the spurious return is for the else branch?

clang/test/AST/Interp/records.cpp

943

Why is x.a outside of its lifetime?

951

I think we should have more test coverage. I mentioned a few above, but other things to test would be inner classes (and anonymous members), like:

struct S {
  struct {
    int x, y;
  } v;
  union {
    float a;
    int b;
  };
};

and member pointers (because those aren't simple pointers):

struct A {
  void func();
};
struct S {
  void (A::*ptr)();
};

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

1493

Unions and bitfields are generally not supported yet, and I'm not sure what you mean by padding bits - they don't exist at this stage. In storage however, they are always zero since we memset that to 0.

clang/lib/AST/Interp/Descriptor.cpp

288–296

I only need an ArrayType anyway, so should be fine.

clang/test/AST/Interp/records.cpp

943

That was just a wrong diagnostic that has since been fixed.

[tbaeder]

clang/test/AST/Interp/records.cpp

951

member pointers are also not handled yet.

[aaron.ballman]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

1493

Unions and bitfields are generally not supported yet,

Let's add the test coverage and mark failures with FIXME comments; otherwise we risk forgetting to add the test coverage later.

and I'm not sure what you mean by padding bits - they don't exist at this stage. In storage however, they are always zero since we memset that to 0.

So long as we're validating that they're properly set to zero; that's the important part.

[aaron.ballman]

LGTM

clang/lib/AST/Interp/ByteCodeExprGen.h

private:
   friend class DestructorScope<Emitter>;
   friend class RecordScope<Emitter>;
   friend class DeclScope<Emitter>;
   friend class OptionScope<Emitter>;
   friend class ArrayIndexScope<Emitter>;
 
   /// Emits a zero initializer.
   bool visitZeroInitializer(QualType QT, const Expr *E);
+  bool visitZeroRecordInitializer(const Record *R, const Expr *E);
 
   enum class DerefKind {
     /// Value is read and pushed to stack.
     Read,
     /// Direct method generates a value which is written. Returns pointer.
     Write,
     /// Direct method receives the value, pushes mutated value. Returns pointer.
     ReadWrite,

clang/lib/AST/Interp/ByteCodeExprGen.cpp

 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCXXConstructExpr(
     const CXXConstructExpr *E) {
   QualType T = E->getType();
   assert(!classify(T));
 
   if (T->isRecordType()) {
-    const Function *Func = getFunction(E->getConstructor());
+    const CXXConstructorDecl *Ctor = E->getConstructor();
+
+    // Trivial zero initialization.
+    if (E->requiresZeroInitialization() && Ctor->isTrivial()) {
+      const Record *R = getRecord(E->getType());
+      return this->visitZeroRecordInitializer(R, E);
+    }
+
+    const Function *Func = getFunction(Ctor);
 
     if (!Func)
       return false;
 
     assert(Func->hasThisPointer());
     assert(!Func->hasRVO());
 
     // If we're discarding a construct expression, we still need
for (size_t I = 0; I != NumElems; ++I) {
 
       if (!this->emitCall(Func, E))
         return false;
     }
     return true;
   }
 
   return false;
 }
 
 template <class Emitter> bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
   if (E->containsErrors())
     return false;
 
   OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/true,
                              /*NewInitializing=*/false);
   return this->Visit(E);
bool ByteCodeExprGen<Emitter>::visitZeroInitializer(QualType QT,
   case PT_Float: {
     return this->emitConstFloat(APFloat::getZero(Ctx.getFloatSemantics(QT)), E);
   }
   }
   llvm_unreachable("unknown primitive type");
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitZeroRecordInitializer(const Record *R,
+                                                          const Expr *E) {
+  assert(E);
+  assert(R);
+  // Fields
+  for (const Record::Field &Field : R->fields()) {
+    const Descriptor *D = Field.Desc;
+    if (D->isPrimitive()) {
+      QualType QT = D->getType();
+      PrimType T = classifyPrim(D->getType());
+      if (!this->visitZeroInitializer(QT, E))
+        return false;
+      if (!this->emitInitField(T, Field.Offset, E))
+        return false;
+      continue;
+    }
+
+    // TODO: Add GetPtrFieldPop and get rid of this dup.
+    if (!this->emitDupPtr(E))
+      return false;
+    if (!this->emitGetPtrField(Field.Offset, E))
+      return false;
+
+    if (D->isPrimitiveArray()) {
+      QualType ET = D->getElemQualType();
+      PrimType T = classifyPrim(ET);
+      for (uint32_t I = 0, N = D->getNumElems(); I != N; ++I) {
+        if (!this->visitZeroInitializer(ET, E))
+          return false;
+        if (!this->emitInitElem(T, I, E))
+          return false;
+      }
+    } else if (D->isCompositeArray()) {
+      const Record *ElemRecord = D->ElemDesc->ElemRecord;
+      assert(D->ElemDesc->ElemRecord);
+      for (uint32_t I = 0, N = D->getNumElems(); I != N; ++I) {
+        if (!this->emitConstUint32(I, E))
+          return false;
+        if (!this->emitArrayElemPtr(PT_Uint32, E))
+          return false;
+        if (!this->visitZeroRecordInitializer(ElemRecord, E))
+          return false;
+        if (!this->emitPopPtr(E))
+          return false;
+      }
+    } else if (D->isRecord()) {
+      if (!this->visitZeroRecordInitializer(D->ElemRecord, E))
+        return false;
+    } else {
+      assert(false);
+    }
+
+    if (!this->emitPopPtr(E))
+      return false;
+  }
+
+  for (const Record::Base &B : R->bases()) {
+    if (!this->emitGetPtrBase(B.Offset, E))
+      return false;
+    if (!this->visitZeroRecordInitializer(B.R, E))
+      return false;
+    if (!this->emitPopPtr(E))
+      return false;
+  }
+
+  // FIXME: Virtual bases.
+
+  return true;
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::dereference(
     const Expr *LV, DerefKind AK, llvm::function_ref<bool(PrimType)> Direct,
     llvm::function_ref<bool(PrimType)> Indirect) {
   if (std::optional<PrimType> T = classify(LV->getType())) {
     if (!LV->refersToBitField()) {
       // Only primitive, non bit-field types can be dereferenced directly.
       if (const auto *DE = dyn_cast<DeclRefExpr>(LV)) {
         if (!DE->getDecl()->getType()->isReferenceType()) {

clang/lib/AST/Interp/Descriptor.h

public:
   /// Allocates a descriptor for an array of composites of unknown size.
   Descriptor(const DeclTy &D, Descriptor *Elem, bool IsTemporary, UnknownSize);
 
   /// Allocates a descriptor for a record.
   Descriptor(const DeclTy &D, Record *R, MetadataSize MD, bool IsConst,
              bool IsTemporary, bool IsMutable);
 
   QualType getType() const;
+  QualType getElemQualType() const;
   SourceLocation getLocation() const;
 
   const Decl *asDecl() const { return Source.dyn_cast<const Decl *>(); }
   const Expr *asExpr() const { return Source.dyn_cast<const Expr *>(); }
 
   const ValueDecl *asValueDecl() const {
     return dyn_cast_if_present<ValueDecl>(asDecl());
   }

clang/lib/AST/Interp/Descriptor.cpp

if (auto *E = asExpr())
     return E->getType();
   if (auto *D = asValueDecl())
     return D->getType();
   if (auto *T = dyn_cast<TypeDecl>(asDecl()))
     return QualType(T->getTypeForDecl(), 0);
   llvm_unreachable("Invalid descriptor type");
 }
 
+QualType Descriptor::getElemQualType() const {
+  assert(isArray());
+  const auto *AT = cast<ArrayType>(getType());
+  return AT->getElementType();
+}
+
 SourceLocation Descriptor::getLocation() const {
   if (auto *D = Source.dyn_cast<const Decl *>())
     return D->getLocation();
   if (auto *E = Source.dyn_cast<const Expr *>())
     return E->getExprLoc();
   llvm_unreachable("Invalid descriptor type");
 }
 
 InitMap::InitMap(unsigned N) : UninitFields(N) {
   std::fill_n(data(), (N + PER_FIELD - 1) / PER_FIELD, 0);
 }

clang/test/AST/Interp/records.cpp

struct F {
     int a;
     constexpr F() : a(12) {}
   };
   constexpr int foo(F f) {
     return 0;
   }
   static_assert(foo(F()) == 0, "");
 }
+
+namespace ZeroInit {
+  struct F {
+    int a;
+  };
+
+  namespace Simple {
+    struct A {
+      char a;
+      bool b;
+      int c[4];
+      float d;
+    };
+    constexpr int foo(A x) {
+      return x.a + static_cast<int>(x.b) + x.c[0] + x.c[3] + static_cast<int>(x.d);
+    }
+    static_assert(foo(A()) == 0, "");
+  }
+
+  namespace Inheritance {
+    struct F2 : F {
+      float f;
+    };
+
+    constexpr int foo(F2 f) {
+      return (int)f.f + f.a;
+    }
+    static_assert(foo(F2()) == 0, "");
+  }
+
+  namespace BitFields {
+    struct F {
+      unsigned a : 6;
+    };
+    constexpr int foo(F f) {
+      return f.a;
+    }
+    static_assert(foo(F()) == 0, "");
+  }
+
+  namespace Nested {
+    struct F2 {
+      float f;
+      char c;
+    };
+
+    struct F {
+      F2 f2;
+      int i;
+    };
+
+    constexpr int foo(F f) {
+      return f.i + f.f2.f + f.f2.c;
+    }
+    static_assert(foo(F()) == 0, "");
+  }
+
+  namespace CompositeArrays {
+    struct F2 {
+      float f;
+      char c;
+    };
+
+    struct F {
+      F2 f2[2];
+      int i;
+    };
+
+    constexpr int foo(F f) {
+      return f.i + f.f2[0].f + f.f2[0].c + f.f2[1].f + f.f2[1].c;
+    }
+    static_assert(foo(F()) == 0, "");
+  }
+
+  /// FIXME: This needs support for unions on the new interpreter.
+  /// We diagnose an uninitialized object in c++14.
+#if __cplusplus > 201402L
+  namespace Unions {
+    struct F {
+      union {
+        int a;
+        char c[4];
+        float f;
+      } U;
+      int i;
+    };
+
+    constexpr int foo(F f) {
+      return f.i + f.U.f; // ref-note {{read of member 'f' of union with active member 'a'}}
+    }
+    static_assert(foo(F()) == 0, ""); // ref-error {{not an integral constant expression}} \
+                                      // ref-note {{in call to}}
+  }
+#endif
+
+#if __cplusplus >= 202002L
+  namespace Failure {
+    struct S {
+      int a;
+      F f{12};
+    };
+    constexpr int foo(S x) {
+      return x.a; // expected-note {{read of uninitialized object}} \
+                  // ref-note {{read of uninitialized object}}
+    }
+    static_assert(foo(S()) == 0, ""); // expected-error {{not an integral constant expression}} \
+                                      // expected-note {{in call to}} \
+                                      // ref-error {{not an integral constant expression}} \
+                                      // ref-note {{in call to}}
+  };
+#endif
+}