[clang][Interp] Track initialization state of local variables

[tbaeder]

Summary

This patch is a bit all over the place, sorry for that. I tried adding comments to Pointer and Block to explain the situation.

We already have a mechanism to track initialization state, i.e. InlineDescriptor. So, this patch adds such an inline descriptor to local variables as well. However, that requires a bit of management in Descriptor.

I didn't add a test for this specifically, but while working on it, plenty of things broke left and right whenever I did something wrong.

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping. This review has been open for a month now and a lot of following functionality depends on it, so if you need to decide which one of the patches to review, choose this one :)

[aaron.ballman]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

805–810

Double checking that Src.is<const Expr *>() is correct here. That's being passed as the IsTemporary argument. I presume the logic is that if the decl type is an expression then it has to be a temporary, but that's not entirely true. Consider C where a compound literal is *not* a temporary but actually creates an lvalue: (int){12}. Will that be an issue?

840

clang/lib/AST/Interp/Interp.h

944

Do we need to initialize() here as well?

956

Same here?

clang/lib/AST/Interp/InterpBlock.h

77–86

Should we have const-correct overloads to provide read-only access?

80–88

Why two levels of reinterpret_cast to the same type?

101

Why do we want to overwrite the metadata here?

clang/lib/AST/Interp/InterpFrame.cpp

34

clang/lib/AST/Interp/Pointer.h

41

43

clang/lib/AST/Interp/Program.cpp

337–338

Why does this one get no metadata while the rest of the descriptors created do?

[erichkeane]

I don't have enough knowledge about how this works to do a better review, but I have a couple of suggestions.

clang/lib/AST/Interp/ByteCodeExprGen.cpp

805–809

See suggested comment below in InterpBlock.

clang/lib/AST/Interp/Descriptor.cpp

212

Theres enough math on stuff like AllocSize/etc that we should probably:

1- do SOMETHING to make sure we're not overflowing
2- Have assertions to make sure we got the sizes looking reasonable.

Additionally, is there any ability to refactor out the common subset of initializers into a constructor and delegate to them instead of all these really fragile looking changes?

clang/lib/AST/Interp/Descriptor.h

102

add a line:
static constexpr MetadataSize InlineDescriptor = MetadataSize{sizeof(InlineDescriptor)};
and you can use this instead of depending on 'sizeof' all over the place.

[shafik]

clang/lib/AST/Interp/Context.cpp

128

clang/lib/AST/Interp/EvalEmitter.cpp

26–27

clang/lib/AST/Interp/Program.h

131

Delete commented out code.

[shafik]

clang/lib/AST/Interp/Descriptor.h

102

It feels weird to call this NoMetadata but we will pass this as an argument to a function with a parameter of MetaDataSize. So I am expecting a size but I am getting no meta data instead and it looks like a mistake.

Maybe a better name would be ZeroMetaDataSize?

clang/lib/AST/Interp/Pointer.h

50

I feel like the comment block in InterpBlock.h is more informative.

347–348

Why the -1

clang/lib/AST/Interp/Program.h

122

130

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

805–810

That interpretation is correct and I don't know what to do about compound literals yet.

clang/lib/AST/Interp/Descriptor.cpp

212

I can try to factor it out into a common constructor. As for overflows, there is code in Program.cpp to handle that (kinda, it doesn't take into account the initmap and matadata size, as far as I can see).

clang/lib/AST/Interp/Descriptor.h

102

I kinda get what your point is, but I don't think this is confusing.

102

I'm a bit concerned about the naming here; InlineDescriptor is already a type name, but calling it MetadataSizeInlineDesc is pretty long and callers already have to prepend a Descriptor:: to that. :/

clang/lib/AST/Interp/Interp.h

944

I think so, but bitfields are currently completely untested.

clang/lib/AST/Interp/InterpBlock.h

77–86

IIRC I added that at least once in a different patch but I abandoned that and haven't had a use for a const overload since.

80–88

No reason. The outer cast isn't needed.

101

This is only called after creating an new block, so nothing is being overwritten, the metadata hasn't been filled-in yet.

clang/lib/AST/Interp/Pointer.h

50

The content might overlap, but they don't describe what Offset and Base mean.

347–348

The inline descriptor is located before the Base (which is what's passed as Offset here). See the comment block added in Pointer.h.

clang/lib/AST/Interp/Program.cpp

337–338

This is the descriptor for the array elements. The metadata passed to this function is only being used for the outermost descriptor, i.e. we use it a few lines below for the actual array but we don't use it for the array elements.

[aaron.ballman]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

805–810

My intuition is that IsTemporary should be set from Expr::isTemporaryObject() (or isa MaterializeTemporaryExpr maybe).

At the very least, you can add a .c test file with a compound literal in a _Static_assert and a FIXME comment (in the test and here in the code).

clang/lib/AST/Interp/Descriptor.h

102

Rather than using a sentinel value, should we be using Optional?

clang/lib/AST/Interp/Interp.h

944

That should be rectified. :-) It seems like that's reasonable to do as part of this patch given it's mostly just two changes here and a few test cases?

clang/lib/AST/Interp/InterpBlock.h

77–86

My worry is that retrofitting const correctness will eventually become too much of a chore and so we'll be adding yet another const-incorrect interface to the compiler. Seeing as how this is being reworked from scratch, I think we should use the opportunity to get better const-correctness, but maybe that ship has sailed?

101

Sounds like a good reason not to memset over that block then; it's useless work that will be thrown away anyway (I worry we may come to rely on this zero init accidentally)?

clang/lib/AST/Interp/Program.cpp

337–338

Don't we need the metadata to track whether the array elements have been initialized? e.g., it's not the array object that gets initialized, it's the elements that do, and we'd want to catch things like:

consteval int func() {
  int a[10];
  return a[2];
}

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

805–810

The Src.is<> is not a change introduced by this patch though.

As for a test, it'll just be rejected because we don't implement visiting CompoundLiterals at all right now.

clang/lib/AST/Interp/Interp.h

944

I can add the initialize() calls but I don't think adding bitfield test cases makes sense for this patch (pretty sure they will fail in unexpected ways anyway).

clang/lib/AST/Interp/InterpBlock.h

77–86

I don't think the ship has sailed at all. Is your argument that the function should be const because it can be? It's slightly problematic because they end up returning const char * as well. I can add the two overloads without problem, just not sure if they end up being used at all right now.

clang/lib/AST/Interp/Program.cpp

337–338

That's what the InitMap is for: it's just a bitmap storing one bit per element of a primitive array for its initialization state.

[aaron.ballman]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

805–810

The Src.is<> is not a change introduced by this patch though.

Then let's add a FIXME comment to remember to come back to look into this (I'm not convinced it was correct to begin with, but it is kind of orthogonal to this patch too).

As for a test, it'll just be rejected because we don't implement visiting CompoundLiterals at all right now.

Fair!

clang/lib/AST/Interp/Descriptor.h

100

I think this should use InterpSize rather than size_t given that it's used to assign into MDSize

102

I'm still wondering if Optional is cleaner than NoMetadata...

167–172

There's some interface awkwardness here where these values are of type InterpSize but the interface returns unsigned

clang/lib/AST/Interp/InterpBlock.h

77–86

I don't think the ship has sailed at all. Is your argument that the function should be const because it can be? It's slightly problematic because they end up returning const char * as well. I can add the two overloads without problem, just not sure if they end up being used at all right now.

My argument is that pairing operations that return a pointer to mutable data with a constant operation that returns a pointer to constant data makes it easier for us to add const-correct code in the future because people are less likely to run into the const correctness "tax" where they have to add overloads/markings virally.

clang/lib/AST/Interp/Program.cpp

337–338

Ahhh okay, thank you for the explanation!

[tbaeder]

clang/lib/AST/Interp/Descriptor.h

102

New version uses Optional<InterpSize>.

167–172

Yes. InterpSize is also only really used in Descriptor.h. No idea why.

[shafik]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

834

Do we really want to the type of the expression? If we have a ValueDecl don't we want that type? I think they should be the same, do you have any examples where the expression is the type we want? I am looking at the AST from int x = 1+1L;

https://godbolt.org/z/q3Tr7Kxoq

clang/lib/AST/Interp/Descriptor.h

73

Maybe IsFieldMutable b/c we call CreateDescriptor it is a little confusing why we have IsConst and IsMutable

clang/lib/AST/Interp/Pointer.h

63–64

or -1u

clang/test/AST/Interp/cxx20.cpp

65–69

Can we also test local arrays and classes as well?

[tbaeder]

clang/lib/AST/Interp/InterpBlock.h

101

FWIW I looked into this and I think zeroing everything is what we want, so the initmap is null initially

[tbaeder]

clang/lib/AST/Interp/Descriptor.h

73

Agreed, but this code was just moved up in this patch, the field was introduced earlier.

clang/lib/AST/Interp/Pointer.h

63–64

Alright, but those were not introduced in this patch.

[aaron.ballman]

clang/lib/AST/Interp/Descriptor.h

73

We can do a renaming pass once this lands, but FWIW, I'm also fine clarifying the names of things as we refactor code.

167–172

Yeah, this should be cleaned up (either here or in an NFC follow-up soon after this lands).

clang/lib/AST/Interp/InterpBlock.h

101

Hmmm, would it make more sense to have the init map setting that itself (in allocate()) rather than relying on invokeCtor() to do it?

clang/lib/AST/Interp/Pointer.h

63–64

Preference for ~0u so the types all match up nicely, fine to do in a post-commit NFC change.

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

834

I don't have a counter example but I didn't write that line either. The Expr case is for temporary values created for AST expressions, not sure what other type to use.

clang/lib/AST/Interp/InterpBlock.h

101

It's a bit blurry to me regarding the layering with Pointer/Descriptor. Descriptors don't know anything about the metadata, but pointers know that primitive arrays have an initmap. So to keep that consistent, we'd have to create a pointer to create the initmap.

But I don't think it's unreasonable to expect zero-initialization for types used in the interpreter.

clang/test/AST/Interp/cxx20.cpp

93

It might be interesting to know that the output for this test changes with https://reviews.llvm.org/D135750. After that patch, we only note that the

[aaron.ballman]

clang/lib/AST/Interp/InterpBlock.h

101

It's a bit blurry to me regarding the layering with Pointer/Descriptor. Descriptors don't know anything about the metadata, but pointers know that primitive arrays have an initmap. So to keep that consistent, we'd have to create a pointer to create the initmap.

But I don't think it's unreasonable to expect zero-initialization for types used in the interpreter.

My concern is the overhead of doing initialization twice in the interpreter. If we're going to zero init and then mostly write over the top of what we initialized, the zero init busywork we don't need to perform. Secondarily, I worry about relying on that zero init when it's not done as part of initialization due to fragility (it's a multi-step init at this point; we allocate, something else zeros, and something else fills in the data).

[tbaeder]

clang/lib/AST/Interp/InterpBlock.h

101

Right, I understand the concerns.

I have looked into using data() instead here, but that causes other problems with arrays of unknown size. (We assert in getSize()). But I know where the right place to initialize the initmap would be now.

As for performance, this shouldn't make a difference to before, since the metadata is always small. We might of course want to get rid of the memset altogether, but both that and not zero-ing the metadata needs a different patch in any case.

So I think this is okay for this patch.

[shafik]

This looks good to me but I see at least one concern that Aaron had that he did not get back on, so I will wait for him to approve.

clang/lib/AST/Interp/ByteCodeExprGen.cpp

834

I think it should be an else if we either have a Decl or an Expr right?

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

408

So by moving the check for Init forward, we will still allocate but we may not initialize.

clang/lib/AST/Interp/Descriptor.h

73

I am happy fixing this separately, please leave a TODO

clang/lib/AST/Interp/Interp.h

918

Can you explain what is going on here? Why do we need to initialize if it is not root?

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

834

Yes, that should work as well.

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

408

Correct.

clang/lib/AST/Interp/Interp.h

918

Root means that Base == 0, so it cannot have a InlineDescriptor before the Base offset. That is mainly the case for global variables.

[shafik]

clang/lib/AST/Interp/Interp.h

918

Can we add a comment that explains this a little better? I still don't get the significance, so I definitely missing something.

Also, why do we initialized before the store?

[tbaeder]

clang/lib/AST/Interp/Interp.h

918

I don't think there's a significance to the order of operations here, some do the init after the store, some the other way around.

[tbaeder]

Add missing inline descriptor handling to local variables created in the EvalEmitter.

[tbaeder]

Ping

[tbaeder]

Ping

[shafik]

LGTM

@aaron.ballman are you happy with this?

[aaron.ballman]

LGTM!

clang/lib/AST/Interp/Pointer.h

63–64

Don't forget to hit this one in post-commit.

clang/lib/AST/Interp/ByteCodeExprGen.cpp

bool ByteCodeExprGen<Emitter>::emitConst(const APSInt &Value, const Expr *E) {
   return this->emitConst(Value.getZExtValue(), E);
 }
 
 template <class Emitter>
 unsigned ByteCodeExprGen<Emitter>::allocateLocalPrimitive(DeclTy &&Src,
                                                           PrimType Ty,
                                                           bool IsConst,
                                                           bool IsExtended) {
-  Descriptor *D = P.createDescriptor(Src, Ty, IsConst, Src.is<const Expr *>());
+  // FIXME: There are cases where Src.is<Expr*>() is wrong, e.g.
+  //   (int){12} in C. Consider using Expr::isTemporaryObject() instead
+  //   or isa<MaterializeTemporaryExpr>().
+  Descriptor *D = P.createDescriptor(Src, Ty, Descriptor::InlineDescMD, IsConst,
+                                     Src.is<const Expr *>());
   Scope::Local Local = this->createLocal(D);
   if (auto *VD = dyn_cast_or_null<ValueDecl>(Src.dyn_cast<const Decl *>()))
     Locals.insert({VD, Local});
   VarScope->add(Local, IsExtended);
   return Local.Offset;
 }
 
 template <class Emitter>
 std::optional<unsigned>
 ByteCodeExprGen<Emitter>::allocateLocal(DeclTy &&Src, bool IsExtended) {
   QualType Ty;
 
   const ValueDecl *Key = nullptr;
   const Expr *Init = nullptr;
   bool IsTemporary = false;
   if (auto *VD = dyn_cast_if_present<ValueDecl>(Src.dyn_cast<const Decl *>())) {
     Key = VD;
     Ty = VD->getType();
 
     if (const auto *VarD = dyn_cast<VarDecl>(VD))
       Init = VarD->getInit();
   }
   if (auto *E = Src.dyn_cast<const Expr *>()) {
     IsTemporary = true;
     Ty = E->getType();
   }
 
   Descriptor *D = P.createDescriptor(
-      Src, Ty.getTypePtr(), Ty.isConstQualified(), IsTemporary, false, Init);
+      Src, Ty.getTypePtr(), Descriptor::InlineDescMD, Ty.isConstQualified(),
+      IsTemporary, /*IsMutable=*/false, Init);
   if (!D)
     return {};
 
   Scope::Local Local = this->createLocal(D);
   if (Key)
     Locals.insert({Key, Local});
   VarScope->add(Local, IsExtended);
   return Local.Offset;
 }

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

if (!VD->hasLocalStorage()) {
     // No code generation required.
     return true;
   }
 
   // Integers, pointers, primitives.
   if (std::optional<PrimType> T = this->classify(VD->getType())) {
     const Expr *Init = VD->getInit();
 
-    if (!Init)
-      return false;
-
     unsigned Offset =
         this->allocateLocalPrimitive(VD, *T, VD->getType().isConstQualified());
     // Compile the initializer in its own scope.
-    {
+    if (Init) {
       ExprScope<Emitter> Scope(this);
       if (!this->visit(Init))
         return false;
-    }
-    // Set the value.
+
       return this->emitSetLocal(*T, Offset, VD);
     }
+    return true;
+  }
 
   // Composite types - allocate storage and initialize it.
-  if (std::optional<unsigned> Offset = this->allocateLocal(VD))
+  if (std::optional<unsigned> Offset = this->allocateLocal(VD)) {
+    if (!VD->getInit())
+      return true;
+
     return this->visitLocalInitializer(VD->getInit(), *Offset);
+  }
 
   return this->bail(VD);
 }
 
 namespace clang {
 namespace interp {
 
 template class ByteCodeStmtGen<ByteCodeEmitter>;
 
 } // namespace interp
 } // namespace clang

clang/lib/AST/Interp/Context.cpp

 }
 
 unsigned Context::getCharBit() const {
   return Ctx.getTargetInfo().getCharWidth();
 }
 
 bool Context::Run(State &Parent, Function *Func, APValue &Result) {
   InterpState State(Parent, *P, Stk, *this);
-  State.Current = new InterpFrame(State, Func, nullptr, {}, {});
+  State.Current = new InterpFrame(State, Func, /*Caller=*/nullptr, {});
   if (Interpret(State, Result))
     return true;
   Stk.clear();
   return false;
 }
 
 bool Context::Check(State &Parent, llvm::Expected<bool> &&Flag) {
   if (Flag)
     return *Flag;
   handleAllErrors(Flag.takeError(), [&Parent](ByteCodeGenError &Err) {
     Parent.FFDiag(Err.getRange().getBegin(),
                   diag::err_experimental_clang_interp_failed)
         << Err.getRange();
   });
   return false;
 }

clang/lib/AST/Interp/Descriptor.h

 /// non-trivial fields, as existing pointers might need to reference those
 /// descriptors. Data is not copied since it cannot be legally read.
 using BlockMoveFn = void (*)(Block *Storage, char *SrcFieldPtr,
                              char *DstFieldPtr, Descriptor *FieldDesc);
 
 /// Object size as used by the interpreter.
 using InterpSize = unsigned;
 
+/// Inline descriptor embedded in structures and arrays.
+///
+/// Such descriptors precede all composite array elements and structure fields.
+/// If the base of a pointer is not zero, the base points to the end of this
+/// structure. The offset field is used to traverse the pointer chain up
+/// to the root structure which allocated the object.
+struct InlineDescriptor {
+  /// Offset inside the structure/array.
+  unsigned Offset;
+
+  /// Flag indicating if the storage is constant or not.
+  /// Relevant for primitive fields.
+  unsigned IsConst : 1;
+  /// For primitive fields, it indicates if the field was initialized.
+  /// Primitive fields in static storage are always initialized.
+  /// Arrays are always initialized, even though their elements might not be.
+  /// Base classes are initialized after the constructor is invoked.
+  unsigned IsInitialized : 1;
+  /// Flag indicating if the field is an embedded base class.
+  unsigned IsBase : 1;
+  /// Flag indicating if the field is the active member of a union.
+  unsigned IsActive : 1;
+  /// Flag indicating if the field is mutable (if in a record).
+  unsigned IsMutable : 1; // TODO: Rename to IsFieldMutable.
+
+  Descriptor *Desc;
+};
+
 /// Describes a memory block created by an allocation site.
 struct Descriptor final {
 private:
   /// Original declaration, used to emit the error message.
   const DeclTy Source;
   /// Size of an element, in host bytes.
   const InterpSize ElemSize;
   /// Size of the storage, in host bytes.
   const InterpSize Size;
+  // Size of the metadata.
+  const InterpSize MDSize;
   /// Size of the allocation (storage + metadata), in host bytes.
   const InterpSize AllocSize;
 
   /// Value to denote arrays of unknown size.
   static constexpr unsigned UnknownSizeMark = (unsigned)-1;
 
 public:
   /// Token to denote structures of unknown size.
   struct UnknownSize {};
 
+  using MetadataSize = std::optional<InterpSize>;
+  static constexpr MetadataSize InlineDescMD = sizeof(InlineDescriptor);
+
   /// Pointer to the record, if block contains records.
   Record *const ElemRecord = nullptr;
   /// Descriptor of the array element.
   Descriptor *const ElemDesc = nullptr;
   /// Flag indicating if the block is mutable.
   const bool IsConst = false;
   /// Flag indicating if a field is mutable.
   const bool IsMutable = false;
   /// Flag indicating if the block is a temporary.
   const bool IsTemporary = false;
   /// Flag indicating if the block is an array.
   const bool IsArray = false;
 
   /// Storage management methods.
   const BlockCtorFn CtorFn = nullptr;
   const BlockDtorFn DtorFn = nullptr;
   const BlockMoveFn MoveFn = nullptr;
 
   /// Allocates a descriptor for a primitive.
-  Descriptor(const DeclTy &D, PrimType Type, bool IsConst, bool IsTemporary,
-             bool IsMutable);
+  Descriptor(const DeclTy &D, PrimType Type, MetadataSize MD, bool IsConst,
+             bool IsTemporary, bool IsMutable);
 
   /// Allocates a descriptor for an array of primitives.
-  Descriptor(const DeclTy &D, PrimType Type, size_t NumElems, bool IsConst,
-             bool IsTemporary, bool IsMutable);
+  Descriptor(const DeclTy &D, PrimType Type, MetadataSize MD, size_t NumElems,
+             bool IsConst, bool IsTemporary, bool IsMutable);
 
   /// Allocates a descriptor for an array of primitives of unknown size.
   Descriptor(const DeclTy &D, PrimType Type, bool IsTemporary, UnknownSize);
 
   /// Allocates a descriptor for an array of composites.
-  Descriptor(const DeclTy &D, Descriptor *Elem, unsigned NumElems, bool IsConst,
-             bool IsTemporary, bool IsMutable);
+  Descriptor(const DeclTy &D, Descriptor *Elem, MetadataSize MD,
+             unsigned NumElems, bool IsConst, bool IsTemporary, bool IsMutable);
 
   /// 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, bool IsConst, bool IsTemporary,
-             bool IsMutable);
+  Descriptor(const DeclTy &D, Record *R, MetadataSize MD, bool IsConst,
+             bool IsTemporary, bool IsMutable);
 
   QualType getType() 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 {
public:
 
   /// Returns the size of the object without metadata.
   unsigned getSize() const {
     assert(!isUnknownSizeArray() && "Array of unknown size");
     return Size;
   }
 
   /// Returns the allocated size, including metadata.
   unsigned getAllocSize() const { return AllocSize; }
   /// returns the size of an element when the structure is viewed as an array.
   unsigned getElemSize()  const { return ElemSize; }
+  /// Returns the size of the metadata.
+  unsigned getMetadataSize() const { return MDSize; }
 
   /// Returns the number of elements stored in the block.
   unsigned getNumElems() const {
     return Size == UnknownSizeMark ? 0 : (getSize() / getElemSize());
   }
 
   /// Checks if the descriptor is of an array of primitives.
   bool isPrimitiveArray() const { return IsArray && !ElemDesc; }
   /// Checks if the descriptor is of an array of zero size.
   bool isZeroSizeArray() const { return Size == 0; }
   /// Checks if the descriptor is of an array of unknown size.
   bool isUnknownSizeArray() const { return Size == UnknownSizeMark; }
 
   /// Checks if the descriptor is of a primitive.
   bool isPrimitive() const { return !IsArray && !ElemRecord; }
 
   /// Checks if the descriptor is of an array.
   bool isArray() const { return IsArray; }
 };
 
-/// Inline descriptor embedded in structures and arrays.
-///
-/// Such descriptors precede all composite array elements and structure fields.
-/// If the base of a pointer is not zero, the base points to the end of this
-/// structure. The offset field is used to traverse the pointer chain up
-/// to the root structure which allocated the object.
-struct InlineDescriptor {
-  /// Offset inside the structure/array.
-  unsigned Offset;
-
-  /// Flag indicating if the storage is constant or not.
-  /// Relevant for primitive fields.
-  unsigned IsConst : 1;
-  /// For primitive fields, it indicates if the field was initialized.
-  /// Primitive fields in static storage are always initialized.
-  /// Arrays are always initialized, even though their elements might not be.
-  /// Base classes are initialized after the constructor is invoked.
-  unsigned IsInitialized : 1;
-  /// Flag indicating if the field is an embedded base class.
-  unsigned IsBase : 1;
-  /// Flag indicating if the field is the active member of a union.
-  unsigned IsActive : 1;
-  /// Flag indicating if the field is mutable (if in a record).
-  unsigned IsMutable : 1;
-
-  Descriptor *Desc;
-};
-
 /// Bitfield tracking the initialisation status of elements of primitive arrays.
 /// A pointer to this is embedded at the end of all primitive arrays.
 /// If the map was not yet created and nothing was initialized, the pointer to
 /// this structure is 0. If the object was fully initialized, the pointer is -1.
 struct InitMap final {
 private:
   /// Type packing bits.
   using T = uint64_t;

clang/lib/AST/Interp/Descriptor.cpp

static BlockDtorFn getDtorArrayPrim(PrimType Type) {
   TYPE_SWITCH(Type, return dtorArrayTy<T>);
   llvm_unreachable("unknown Expr");
 }
 
 static BlockMoveFn getMoveArrayPrim(PrimType Type) {
   COMPOSITE_TYPE_SWITCH(Type, return moveArrayTy<T>, return nullptr);
 }
 
-Descriptor::Descriptor(const DeclTy &D, PrimType Type, bool IsConst,
-                       bool IsTemporary, bool IsMutable)
-    : Source(D), ElemSize(primSize(Type)), Size(ElemSize), AllocSize(Size),
-      IsConst(IsConst), IsMutable(IsMutable), IsTemporary(IsTemporary),
-      CtorFn(getCtorPrim(Type)), DtorFn(getDtorPrim(Type)),
-      MoveFn(getMovePrim(Type)) {
+Descriptor::Descriptor(const DeclTy &D, PrimType Type, MetadataSize MD,
+                       bool IsConst, bool IsTemporary, bool IsMutable)
+    : Source(D), ElemSize(primSize(Type)), Size(ElemSize),
+      MDSize(MD.value_or(0)), AllocSize(align(Size + MDSize)), IsConst(IsConst),
+      IsMutable(IsMutable), IsTemporary(IsTemporary), CtorFn(getCtorPrim(Type)),
+      DtorFn(getDtorPrim(Type)), MoveFn(getMovePrim(Type)) {
+  assert(AllocSize >= Size);
   assert(Source && "Missing source");
 }
 
-Descriptor::Descriptor(const DeclTy &D, PrimType Type, size_t NumElems,
-                       bool IsConst, bool IsTemporary, bool IsMutable)
+Descriptor::Descriptor(const DeclTy &D, PrimType Type, MetadataSize MD,
+                       size_t NumElems, bool IsConst, bool IsTemporary,
+                       bool IsMutable)
     : Source(D), ElemSize(primSize(Type)), Size(ElemSize * NumElems),
-      AllocSize(align(Size) + sizeof(InitMap *)), IsConst(IsConst),
+      MDSize(MD.value_or(0)),
+      AllocSize(align(Size) + sizeof(InitMap *) + MDSize), IsConst(IsConst),
       IsMutable(IsMutable), IsTemporary(IsTemporary), IsArray(true),
       CtorFn(getCtorArrayPrim(Type)), DtorFn(getDtorArrayPrim(Type)),
       MoveFn(getMoveArrayPrim(Type)) {
   assert(Source && "Missing source");
 }
 
 Descriptor::Descriptor(const DeclTy &D, PrimType Type, bool IsTemporary,
                        UnknownSize)
-    : Source(D), ElemSize(primSize(Type)), Size(UnknownSizeMark),
+    : Source(D), ElemSize(primSize(Type)), Size(UnknownSizeMark), MDSize(0),
       AllocSize(alignof(void *)), IsConst(true), IsMutable(false),
       IsTemporary(IsTemporary), IsArray(true), CtorFn(getCtorArrayPrim(Type)),
       DtorFn(getDtorArrayPrim(Type)), MoveFn(getMoveArrayPrim(Type)) {
   assert(Source && "Missing source");
 }
 
-Descriptor::Descriptor(const DeclTy &D, Descriptor *Elem, unsigned NumElems,
-                       bool IsConst, bool IsTemporary, bool IsMutable)
+Descriptor::Descriptor(const DeclTy &D, Descriptor *Elem, MetadataSize MD,
+                       unsigned NumElems, bool IsConst, bool IsTemporary,
+                       bool IsMutable)
     : Source(D), ElemSize(Elem->getAllocSize() + sizeof(InlineDescriptor)),
-      Size(ElemSize * NumElems),
-      AllocSize(std::max<size_t>(alignof(void *), Size)), ElemDesc(Elem),
-      IsConst(IsConst), IsMutable(IsMutable), IsTemporary(IsTemporary),
-      IsArray(true), CtorFn(ctorArrayDesc), DtorFn(dtorArrayDesc),
-      MoveFn(moveArrayDesc) {
+      Size(ElemSize * NumElems), MDSize(MD.value_or(0)),
+      AllocSize(std::max<size_t>(alignof(void *), Size) + MDSize),
+      ElemDesc(Elem), IsConst(IsConst), IsMutable(IsMutable),
+      IsTemporary(IsTemporary), IsArray(true), CtorFn(ctorArrayDesc),
+      DtorFn(dtorArrayDesc), MoveFn(moveArrayDesc) {
   assert(Source && "Missing source");
 }
 
 Descriptor::Descriptor(const DeclTy &D, Descriptor *Elem, bool IsTemporary,
                        UnknownSize)
     : Source(D), ElemSize(Elem->getAllocSize() + sizeof(InlineDescriptor)),
-      Size(UnknownSizeMark), AllocSize(alignof(void *)), ElemDesc(Elem),
-      IsConst(true), IsMutable(false), IsTemporary(IsTemporary), IsArray(true),
-      CtorFn(ctorArrayDesc), DtorFn(dtorArrayDesc), MoveFn(moveArrayDesc) {
+      Size(UnknownSizeMark), MDSize(0), AllocSize(alignof(void *)),
+      ElemDesc(Elem), IsConst(true), IsMutable(false), IsTemporary(IsTemporary),
+      IsArray(true), CtorFn(ctorArrayDesc), DtorFn(dtorArrayDesc),
+      MoveFn(moveArrayDesc) {
   assert(Source && "Missing source");
 }
 
-Descriptor::Descriptor(const DeclTy &D, Record *R, bool IsConst,
-                       bool IsTemporary, bool IsMutable)
+Descriptor::Descriptor(const DeclTy &D, Record *R, MetadataSize MD,
+                       bool IsConst, bool IsTemporary, bool IsMutable)
     : Source(D), ElemSize(std::max<size_t>(alignof(void *), R->getFullSize())),
-      Size(ElemSize), AllocSize(Size), ElemRecord(R), IsConst(IsConst),
-      IsMutable(IsMutable), IsTemporary(IsTemporary), CtorFn(ctorRecord),
-      DtorFn(dtorRecord), MoveFn(moveRecord) {
+      Size(ElemSize), MDSize(MD.value_or(0)), AllocSize(Size + MDSize),
+      ElemRecord(R), IsConst(IsConst), IsMutable(IsMutable),
+      IsTemporary(IsTemporary), CtorFn(ctorRecord), DtorFn(dtorRecord),
+      MoveFn(moveRecord) {
   assert(Source && "Missing source");
 }
 
 QualType Descriptor::getType() const {
   if (auto *E = asExpr())
     return E->getType();
   if (auto *D = asValueDecl())
     return D->getType();

clang/lib/AST/Interp/EvalEmitter.cpp

 
 using APSInt = llvm::APSInt;
 template <typename T> using Expected = llvm::Expected<T>;
 
 EvalEmitter::EvalEmitter(Context &Ctx, Program &P, State &Parent,
                          InterpStack &Stk, APValue &Result)
     : Ctx(Ctx), P(P), S(Parent, P, Stk, Ctx, this), Result(Result) {
   // Create a dummy frame for the interpreter which does not have locals.
-  S.Current = new InterpFrame(S, nullptr, nullptr, CodePtr(), Pointer());
+  S.Current =
+      new InterpFrame(S, /*Func=*/nullptr, /*Caller=*/nullptr, CodePtr());
 }
 
 llvm::Expected<bool> EvalEmitter::interpretExpr(const Expr *E) {
   if (this->visitExpr(E))
     return true;
   if (BailLocation)
     return llvm::make_error<ByteCodeGenError>(*BailLocation);
   return false;

 EvalEmitter::LabelTy EvalEmitter::getLabel() { return NextLabel++; }
 
 Scope::Local EvalEmitter::createLocal(Descriptor *D) {
   // Allocate memory for a local.
   auto Memory = std::make_unique<char[]>(sizeof(Block) + D->getAllocSize());
   auto *B = new (Memory.get()) Block(D, /*isStatic=*/false);
   B->invokeCtor();
 
+  // Initialize local variable inline descriptor.
+  InlineDescriptor &Desc = *reinterpret_cast<InlineDescriptor *>(B->rawData());
+  Desc.Desc = D;
+  Desc.Offset = sizeof(InlineDescriptor);
+  Desc.IsActive = true;
+
   // Register the local.
   unsigned Off = Locals.size();
   Locals.insert({Off, std::move(Memory)});
   return {Off, D};
 }
 
 bool EvalEmitter::bail(const SourceLocation &Loc) {
   if (!BailLocation)

 }
 
 bool EvalEmitter::emitGetPtrLocal(uint32_t I, const SourceInfo &Info) {
   if (!isActive())
     return true;
 
   auto It = Locals.find(I);
   assert(It != Locals.end() && "Missing local variable");
-  S.Stk.push<Pointer>(reinterpret_cast<Block *>(It->second.get()));
+  Block *B = reinterpret_cast<Block *>(It->second.get());
+  S.Stk.push<Pointer>(B, sizeof(InlineDescriptor));
   return true;
 }
 
 template <PrimType OpType>
 bool EvalEmitter::emitGetLocal(uint32_t I, const SourceInfo &Info) {
   if (!isActive())
     return true;
 
   using T = typename PrimConv<OpType>::T;
 
   auto It = Locals.find(I);
   assert(It != Locals.end() && "Missing local variable");
   auto *B = reinterpret_cast<Block *>(It->second.get());
-  S.Stk.push<T>(*reinterpret_cast<T *>(B + 1));
+  S.Stk.push<T>(*reinterpret_cast<T *>(B->data()));
   return true;
 }
 
 template <PrimType OpType>
 bool EvalEmitter::emitSetLocal(uint32_t I, const SourceInfo &Info) {
   if (!isActive())
     return true;
 
   using T = typename PrimConv<OpType>::T;
 
   auto It = Locals.find(I);
   assert(It != Locals.end() && "Missing local variable");
   auto *B = reinterpret_cast<Block *>(It->second.get());
-  *reinterpret_cast<T *>(B + 1) = S.Stk.pop<T>();
+  *reinterpret_cast<T *>(B->data()) = S.Stk.pop<T>();
+  InlineDescriptor &Desc = *reinterpret_cast<InlineDescriptor *>(B->rawData());
+  Desc.IsInitialized = true;
+
   return true;
 }
 
 bool EvalEmitter::emitDestroy(uint32_t I, const SourceInfo &Info) {
   if (!isActive())
     return true;
 
   for (auto &Local : Descriptors[I]) {

clang/lib/AST/Interp/Interp.h

 }
 
 //===----------------------------------------------------------------------===//
 // Get/Set Local/Param/Global/This
 //===----------------------------------------------------------------------===//
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool GetLocal(InterpState &S, CodePtr OpPC, uint32_t I) {
-  S.Stk.push<T>(S.Current->getLocal<T>(I));
+  const Pointer &Ptr = S.Current->getLocalPointer(I);
+  if (!CheckLoad(S, OpPC, Ptr))
+    return false;
+  S.Stk.push<T>(Ptr.deref<T>());
   return true;
 }
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool SetLocal(InterpState &S, CodePtr OpPC, uint32_t I) {
   S.Current->setLocal<T>(I, S.Stk.pop<T>());
   return true;
 }

 }
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Store(InterpState &S, CodePtr OpPC) {
   const T &Value = S.Stk.pop<T>();
   const Pointer &Ptr = S.Stk.peek<Pointer>();
   if (!CheckStore(S, OpPC, Ptr))
     return false;
+  if (!Ptr.isRoot())
+    Ptr.initialize();
   Ptr.deref<T>() = Value;
   return true;
 }
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool StorePop(InterpState &S, CodePtr OpPC) {
   const T &Value = S.Stk.pop<T>();
   const Pointer &Ptr = S.Stk.pop<Pointer>();
   if (!CheckStore(S, OpPC, Ptr))
     return false;
+  if (!Ptr.isRoot())
+    Ptr.initialize();
   Ptr.deref<T>() = Value;
   return true;
 }
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool StoreBitField(InterpState &S, CodePtr OpPC) {
   const T &Value = S.Stk.pop<T>();
   const Pointer &Ptr = S.Stk.peek<Pointer>();
   if (!CheckStore(S, OpPC, Ptr))
     return false;
+  if (!Ptr.isRoot())
+    Ptr.initialize();
   if (auto *FD = Ptr.getField()) {
     Ptr.deref<T>() = Value.truncate(FD->getBitWidthValue(S.getCtx()));
   } else {
     Ptr.deref<T>() = Value;
   }
   return true;
 }
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool StoreBitFieldPop(InterpState &S, CodePtr OpPC) {
   const T &Value = S.Stk.pop<T>();
   const Pointer &Ptr = S.Stk.pop<Pointer>();
   if (!CheckStore(S, OpPC, Ptr))
     return false;
+  if (!Ptr.isRoot())
+    Ptr.initialize();
   if (auto *FD = Ptr.getField()) {
     Ptr.deref<T>() = Value.truncate(FD->getBitWidthValue(S.getCtx()));
   } else {
     Ptr.deref<T>() = Value;
   }
   return true;
 }
 

clang/lib/AST/Interp/InterpBlock.h

 class Block;
 class DeadBlock;
 class InterpState;
 class Pointer;
 enum PrimType : unsigned;
 
 /// A memory block, either on the stack or in the heap.
 ///
-/// The storage described by the block immediately follows it in memory.
+/// The storage described by the block is immediately followed by
+/// optional metadata, which is followed by the actual data.
+///
+/// Block*        rawData()                  data()
+/// │               │                         │
+/// │               │                         │
+/// ▼               ▼                         ▼
+/// ┌───────────────┬─────────────────────────┬─────────────────┐
+/// │ Block         │ Metadata                │ Data            │
+/// │ sizeof(Block) │ Desc->getMetadataSize() │ Desc->getSize() │
+/// └───────────────┴─────────────────────────┴─────────────────┘
+///
+/// Desc->getAllocSize() describes the size after the Block, i.e.
+/// the data size and the metadata size.
+///
 class Block final {
 public:
   // Creates a new block.
   Block(const std::optional<unsigned> &DeclID, Descriptor *Desc,
         bool IsStatic = false, bool IsExtern = false)
       : DeclID(DeclID), IsStatic(IsStatic), IsExtern(IsExtern), Desc(Desc) {}
 
   Block(Descriptor *Desc, bool IsStatic = false, bool IsExtern = false)
public:
   /// Checks if the block is temporary.
   bool isTemporary() const { return Desc->IsTemporary; }
   /// Returns the size of the block.
   InterpSize getSize() const { return Desc->getAllocSize(); }
   /// Returns the declaration ID.
   std::optional<unsigned> getDeclID() const { return DeclID; }
 
   /// Returns a pointer to the stored data.
-  char *data() { return reinterpret_cast<char *>(this + 1); }
+  /// You are allowed to read Desc->getSize() bytes from this address.
+  char *data() {
+    // rawData might contain metadata as well.
+    size_t DataOffset = Desc->getMetadataSize();
+    return rawData() + DataOffset;
+  }
+  const char *data() const {
+    // rawData might contain metadata as well.
+    size_t DataOffset = Desc->getMetadataSize();
+    return rawData() + DataOffset;
+  }
+
+  /// Returns a pointer to the raw data, including metadata.
+  /// You are allowed to read Desc->getAllocSize() bytes from this address.
+  char *rawData() { return reinterpret_cast<char *>(this) + sizeof(Block); }
+  const char *rawData() const {
+    return reinterpret_cast<const char *>(this) + sizeof(Block);
+  }
 
   /// Returns a view over the data.
   template <typename T>
   T &deref() { return *reinterpret_cast<T *>(data()); }
 
   /// Invokes the constructor.
   void invokeCtor() {
-    std::memset(data(), 0, getSize());
+    std::memset(rawData(), 0, Desc->getAllocSize());
     if (Desc->CtorFn)
       Desc->CtorFn(this, data(), Desc->IsConst, Desc->IsMutable,
                    /*isActive=*/true, Desc);
   }
 
   // Invokes the Destructor.
   void invokeDtor() {
     if (Desc->DtorFn)

clang/lib/AST/Interp/InterpFrame.h

 /// Frame storing local variables.
 class InterpFrame final : public Frame {
 public:
   /// The frame of the previous function.
   InterpFrame *Caller;
 
   /// Creates a new frame for a method call.
   InterpFrame(InterpState &S, const Function *Func, InterpFrame *Caller,
-              CodePtr RetPC, Pointer &&This);
+              CodePtr RetPC);
 
   /// Creates a new frame with the values that make sense.
   /// I.e., the caller is the current frame of S,
   /// the This() pointer is the current Pointer on the top of S's stack,
   /// and the RVO pointer is before that.
   InterpFrame(InterpState &S, const Function *Func, CodePtr RetPC);
 
   /// Destroys the frame, killing all live pointers to stack slots.
public:
   /// Returns the value of a local variable.
   template <typename T> const T &getLocal(unsigned Offset) const {
     return localRef<T>(Offset);
   }
 
   /// Mutates a local variable.
   template <typename T> void setLocal(unsigned Offset, const T &Value) {
     localRef<T>(Offset) = Value;
+    localInlineDesc(Offset)->IsInitialized = true;
   }
 
   /// Returns a pointer to a local variables.
-  Pointer getLocalPointer(unsigned Offset);
+  Pointer getLocalPointer(unsigned Offset) const;
 
   /// Returns the value of an argument.
   template <typename T> const T &getParam(unsigned Offset) const {
     auto Pt = Params.find(Offset);
     if (Pt == Params.end()) {
       return stackRef<T>(Offset);
     } else {
       return Pointer(reinterpret_cast<Block *>(Pt->second.get())).deref<T>();
private:
   /// Returns an original argument from the stack.
   template <typename T> const T &stackRef(unsigned Offset) const {
     assert(Args);
     return *reinterpret_cast<const T *>(Args - ArgSize + Offset);
   }
 
   /// Returns an offset to a local.
   template <typename T> T &localRef(unsigned Offset) const {
-    return *reinterpret_cast<T *>(Locals.get() + Offset);
+    return getLocalPointer(Offset).deref<T>();
   }
 
   /// Returns a pointer to a local's block.
   void *localBlock(unsigned Offset) const {
     return Locals.get() + Offset - sizeof(Block);
   }
 
+  // Returns the inline descriptor of the local.
+  InlineDescriptor *localInlineDesc(unsigned Offset) const {
+    return reinterpret_cast<InlineDescriptor *>(Locals.get() + Offset);
+  }
+
 private:
   /// Reference to the interpreter state.
   InterpState &S;
   /// Reference to the function being executed.
   const Function *Func;
   /// Current object pointer for methods.
   Pointer This;
   /// Pointer the non-primitive return value gets constructed in.

clang/lib/AST/Interp/InterpFrame.cpp

 #include "Program.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 InterpFrame::InterpFrame(InterpState &S, const Function *Func,
-                         InterpFrame *Caller, CodePtr RetPC, Pointer &&This)
-    : Caller(Caller), S(S), Func(Func), This(std::move(This)), RetPC(RetPC),
+                         InterpFrame *Caller, CodePtr RetPC)
+    : Caller(Caller), S(S), Func(Func), RetPC(RetPC),
       ArgSize(Func ? Func->getArgSize() : 0),
       Args(static_cast<char *>(S.Stk.top())), FrameOffset(S.Stk.size()) {
   if (Func) {
     if (unsigned FrameSize = Func->getFrameSize()) {
       Locals = std::make_unique<char[]>(FrameSize);
       for (auto &Scope : Func->scopes()) {
         for (auto &Local : Scope.locals()) {
           Block *B = new (localBlock(Local.Offset)) Block(Local.Desc);
           B->invokeCtor();
+          InlineDescriptor *ID = localInlineDesc(Local.Offset);
+          ID->Desc = Local.Desc;
+          ID->IsActive = true;
+          ID->Offset = sizeof(InlineDescriptor);
         }
       }
     }
   }
 }
 
 InterpFrame::InterpFrame(InterpState &S, const Function *Func, CodePtr RetPC)
-    : Caller(S.Current), S(S), Func(Func), RetPC(RetPC),
-      ArgSize(Func ? Func->getArgSize() : 0),
-      Args(static_cast<char *>(S.Stk.top())), FrameOffset(S.Stk.size()) {
-  assert(Func);
-
+    : InterpFrame(S, Func, S.Current, RetPC) {
   // As per our calling convention, the this pointer is
   // part of the ArgSize.
   // If the function has RVO, the RVO pointer is first.
   // If the fuction has a This pointer, that one is next.
   // Then follow the actual arguments (but those are handled
   // in getParamPointer()).
   if (Func->hasRVO())
     RVOPtr = stackRef<Pointer>(0);
 
   if (Func->hasThisPointer()) {
     if (Func->hasRVO())
       This = stackRef<Pointer>(sizeof(Pointer));
     else
       This = stackRef<Pointer>(0);
   }
-
-  if (unsigned FrameSize = Func->getFrameSize()) {
-    Locals = std::make_unique<char[]>(FrameSize);
-    for (auto &Scope : Func->scopes()) {
-      for (auto &Local : Scope.locals()) {
-        Block *B = new (localBlock(Local.Offset)) Block(Local.Desc);
-        B->invokeCtor();
-      }
-    }
-  }
 }
 
 InterpFrame::~InterpFrame() {
   if (Func && Func->isConstructor() && This.isBaseClass())
     This.initialize();
   for (auto &Param : Params)
     S.deallocate(reinterpret_cast<Block *>(Param.second.get()));
 }
if (!Caller->Func)
     return S.getLocation(nullptr, {});
   return S.getLocation(Caller->Func, RetPC - sizeof(uintptr_t));
 }
 
 const FunctionDecl *InterpFrame::getCallee() const {
   return Func->getDecl();
 }
 
-Pointer InterpFrame::getLocalPointer(unsigned Offset) {
+Pointer InterpFrame::getLocalPointer(unsigned Offset) const {
   assert(Offset < Func->getFrameSize() && "Invalid local offset.");
-  return Pointer(
-      reinterpret_cast<Block *>(Locals.get() + Offset - sizeof(Block)));
+  return Pointer(reinterpret_cast<Block *>(localBlock(Offset)),
+                 sizeof(InlineDescriptor));
 }
 
 Pointer InterpFrame::getParamPointer(unsigned Off) {
   // Return the block if it was created previously.
   auto Pt = Params.find(Off);
   if (Pt != Params.end()) {
     return Pointer(reinterpret_cast<Block *>(Pt->second.get()));
   }

clang/lib/AST/Interp/Pointer.h

 class DeadBlock;
 class Pointer;
 enum PrimType : unsigned;
 
 /// A pointer to a memory block, live or dead.
 ///
 /// This object can be allocated into interpreter stack frames. If pointing to
 /// a live block, it is a link in the chain of pointers pointing to the block.
+///
+/// In the simplest form, a Pointer has a Block* (the pointee) and both Base
+/// and Offset are 0, which means it will point to raw data.
+///
+/// The Base field is used to access metadata about the data. For primitive
+/// arrays, the Base is followed by an InitMap. In a variety of cases, the
+/// Base is preceded by an InlineDescriptor, which is used to track the
+/// initialization state, among other things.
+///
+/// The Offset field is used to access the actual data. In other words, the
+/// data the pointer decribes can be found at
+/// Pointee->rawData() + Pointer.Offset.
+///
+///
+/// Pointee                      Offset
+/// │                              │
+/// │                              │
+/// ▼                              ▼
+/// ┌───────┬────────────┬─────────┬────────────────────────────┐
+/// │ Block │ InlineDesc │ InitMap │ Actual Data                │
+/// └───────┴────────────┴─────────┴────────────────────────────┘
+///                      ▲
+///                      │
+///                      │
+///                     Base
 class Pointer {
 private:
   static constexpr unsigned PastEndMark = (unsigned)-1;
   static constexpr unsigned RootPtrMark = (unsigned)-1;
 
 public:
   Pointer() {}
   Pointer(Block *B);
+  Pointer(Block *B, unsigned BaseAndOffset);
   Pointer(const Pointer &P);
   Pointer(Pointer &&P);
   ~Pointer();
 
   void operator=(const Pointer &P);
   void operator=(Pointer &&P);
 
   /// Converts the pointer to an APValue.
public:
   }
 
   /// Checks if the pointer is an out-of-bounds element pointer.
   bool isElementPastEnd() const { return Offset == PastEndMark; }
 
   /// Dereferences the pointer, if it's live.
   template <typename T> T &deref() const {
     assert(isLive() && "Invalid pointer");
-    return *reinterpret_cast<T *>(Pointee->data() + Offset);
+    return *reinterpret_cast<T *>(Pointee->rawData() + Offset);
   }
 
   /// Dereferences a primitive element.
   template <typename T> T &elem(unsigned I) const {
-    return reinterpret_cast<T *>(Pointee->data())[I];
+    return reinterpret_cast<T *>(Pointee->rawData())[I];
   }
 
   /// Initializes a field.
   void initialize() const;
   /// Activats a field.
   void activate() const;
   /// Deactivates an entire strurcutre.
   void deactivate() const;
private:
   Pointer(Block *Pointee, unsigned Base, unsigned Offset);
 
   /// Returns the embedded descriptor preceding a field.
   InlineDescriptor *getInlineDesc() const { return getDescriptor(Base); }
 
   /// Returns a descriptor at a given offset.
   InlineDescriptor *getDescriptor(unsigned Offset) const {
     assert(Offset != 0 && "Not a nested pointer");
-    return reinterpret_cast<InlineDescriptor *>(Pointee->data() + Offset) - 1;
+    return reinterpret_cast<InlineDescriptor *>(Pointee->rawData() + Offset) -
+           1;
   }
 
   /// Returns a reference to the pointer which stores the initialization map.
   InitMap *&getInitMap() const {
-    return *reinterpret_cast<InitMap **>(Pointee->data() + Base);
+    return *reinterpret_cast<InitMap **>(Pointee->rawData() + Base);
   }
 
   /// The block the pointer is pointing to.
   Block *Pointee = nullptr;
   /// Start of the current subfield.
   unsigned Base = 0;
   /// Offset into the block.
   unsigned Offset = 0;

clang/lib/AST/Interp/Pointer.cpp

 #include "InterpBlock.h"
 #include "PrimType.h"
 
 using namespace clang;
 using namespace clang::interp;
 
 Pointer::Pointer(Block *Pointee) : Pointer(Pointee, 0, 0) {}
 
+Pointer::Pointer(Block *Pointee, unsigned BaseAndOffset)
+    : Pointer(Pointee, BaseAndOffset, BaseAndOffset) {}
+
 Pointer::Pointer(const Pointer &P) : Pointer(P.Pointee, P.Base, P.Offset) {}
 
 Pointer::Pointer(Pointer &&P)
     : Pointee(P.Pointee), Base(P.Base), Offset(P.Offset) {
   if (Pointee)
     Pointee->movePointer(&P, this);
 }
 

clang/lib/AST/Interp/Program.h

public:
   /// Returns a function.
   Function *getFunction(const FunctionDecl *F);
 
   /// Returns a record or creates one if it does not exist.
   Record *getOrCreateRecord(const RecordDecl *RD);
 
   /// Creates a descriptor for a primitive type.
   Descriptor *createDescriptor(const DeclTy &D, PrimType Type,
-                               bool IsConst = false,
-                               bool IsTemporary = false,
+                               Descriptor::MetadataSize MDSize = std::nullopt,
+                               bool IsConst = false, bool IsTemporary = false,
                                bool IsMutable = false) {
-    return allocateDescriptor(D, Type, IsConst, IsTemporary, IsMutable);
+    return allocateDescriptor(D, Type, MDSize, IsConst, IsTemporary, IsMutable);
   }
 
   /// Creates a descriptor for a composite type.
   Descriptor *createDescriptor(const DeclTy &D, const Type *Ty,
+                               Descriptor::MetadataSize MDSize = std::nullopt,
                                bool IsConst = false, bool IsTemporary = false,
                                bool IsMutable = false,
                                const Expr *Init = nullptr);
 
   /// Context to manage declaration lifetimes.
   class DeclScope {
   public:
     DeclScope(Program &P, const VarDecl *VD) : P(P) { P.startDeclaration(VD); }
     ~DeclScope() { P.endDeclaration(); }
 
   private:
     Program &P;
   };
 

clang/lib/AST/Interp/Program.cpp

unsigned Program::createGlobalString(const StringLiteral *S) {
   case 4:
     CharType = PT_Uint32;
     break;
   default:
     llvm_unreachable("unsupported character width");
   }
 
   // Create a descriptor for the string.
-  Descriptor *Desc = allocateDescriptor(S, CharType, S->getLength() + 1,
-                                        /*isConst=*/true,
-                                        /*isTemporary=*/false,
-                                        /*isMutable=*/false);
+  Descriptor *Desc =
+      allocateDescriptor(S, CharType, std::nullopt, S->getLength() + 1,
 
   // Allocate storage for the string.
   // The byte length does not include the null terminator.
   unsigned I = Globals.size();
   unsigned Sz = Desc->getAllocSize();
   auto *G = new (Allocator, Sz) Global(Desc, /*isStatic=*/true,
                                        /*isExtern=*/false);
   G->block()->invokeCtor();

 std::optional<unsigned> Program::createGlobal(const DeclTy &D, QualType Ty,
                                               bool IsStatic, bool IsExtern,
                                               const Expr *Init) {
   // Create a descriptor for the global.
   Descriptor *Desc;
   const bool IsConst = Ty.isConstQualified();
   const bool IsTemporary = D.dyn_cast<const Expr *>();
   if (auto T = Ctx.classify(Ty)) {
-    Desc = createDescriptor(D, *T, IsConst, IsTemporary);
+    Desc = createDescriptor(D, *T, std::nullopt, IsConst, IsTemporary);
   } else {
-    Desc = createDescriptor(D, Ty.getTypePtr(), IsConst, IsTemporary);
+    Desc = createDescriptor(D, Ty.getTypePtr(), std::nullopt, IsConst,
+                            IsTemporary);
   }
   if (!Desc)
     return {};
 
   // Allocate a block for storage.
   unsigned I = Globals.size();
 
   auto *G = new (Allocator, Desc->getAllocSize())
Record *Program::getOrCreateRecord(const RecordDecl *RD) {
   unsigned BaseSize = 0;
   // Number of bytes required by virtual base.
   unsigned VirtSize = 0;
 
   // Helper to get a base descriptor.
   auto GetBaseDesc = [this](const RecordDecl *BD, Record *BR) -> Descriptor * {
     if (!BR)
       return nullptr;
-    return allocateDescriptor(BD, BR, /*isConst=*/false,
+    return allocateDescriptor(BD, BR, std::nullopt, /*isConst=*/false,
                               /*isTemporary=*/false,
                               /*isMutable=*/false);
   };
 
   // Reserve space for base classes.
   Record::BaseList Bases;
   Record::VirtualBaseList VirtBases;
   if (auto *CD = dyn_cast<CXXRecordDecl>(RD)) {
for (const FieldDecl *FD : RD->fields()) {
     BaseSize += align(sizeof(InlineDescriptor));
 
     // Classify the field and add its metadata.
     QualType FT = FD->getType();
     const bool IsConst = FT.isConstQualified();
     const bool IsMutable = FD->isMutable();
     Descriptor *Desc;
     if (std::optional<PrimType> T = Ctx.classify(FT)) {
-      Desc = createDescriptor(FD, *T, IsConst, /*isTemporary=*/false,
-                              IsMutable);
+      Desc = createDescriptor(FD, *T, std::nullopt, IsConst,
+                              /*isTemporary=*/false, IsMutable);
     } else {
-      Desc = createDescriptor(FD, FT.getTypePtr(), IsConst,
+      Desc = createDescriptor(FD, FT.getTypePtr(), std::nullopt, IsConst,
                               /*isTemporary=*/false, IsMutable);
     }
     if (!Desc)
       return nullptr;
     Fields.push_back({FD, BaseSize, Desc});
     BaseSize += align(Desc->getAllocSize());
   }
 
   Record *R = new (Allocator) Record(RD, std::move(Bases), std::move(Fields),
                                      std::move(VirtBases), VirtSize, BaseSize);
   Records[RD] = R;
   return R;
 }
 
 Descriptor *Program::createDescriptor(const DeclTy &D, const Type *Ty,
+                                      Descriptor::MetadataSize MDSize,
                                       bool IsConst, bool IsTemporary,
                                       bool IsMutable, const Expr *Init) {
   // Classes and structures.
   if (auto *RT = Ty->getAs<RecordType>()) {
     if (auto *Record = getOrCreateRecord(RT->getDecl()))
-      return allocateDescriptor(D, Record, IsConst, IsTemporary, IsMutable);
+      return allocateDescriptor(D, Record, MDSize, IsConst, IsTemporary,
+                                IsMutable);
   }
 
   // Arrays.
   if (auto ArrayType = Ty->getAsArrayTypeUnsafe()) {
     QualType ElemTy = ArrayType->getElementType();
     // Array of well-known bounds.
     if (auto CAT = dyn_cast<ConstantArrayType>(ArrayType)) {
       size_t NumElems = CAT->getSize().getZExtValue();
       if (std::optional<PrimType> T = Ctx.classify(ElemTy)) {
         // Arrays of primitives.
         unsigned ElemSize = primSize(*T);
         if (std::numeric_limits<unsigned>::max() / ElemSize <= NumElems) {
           return {};
         }
-        return allocateDescriptor(D, *T, NumElems, IsConst, IsTemporary,
+        return allocateDescriptor(D, *T, MDSize, NumElems, IsConst, IsTemporary,
                                   IsMutable);
       } else {
         // Arrays of composites. In this case, the array is a list of pointers,
         // followed by the actual elements.
-        Descriptor *ElemDesc =
-            createDescriptor(D, ElemTy.getTypePtr(), IsConst, IsTemporary);
+        Descriptor *ElemDesc = createDescriptor(
+            D, ElemTy.getTypePtr(), std::nullopt, IsConst, IsTemporary);
         if (!ElemDesc)
           return nullptr;
         InterpSize ElemSize =
             ElemDesc->getAllocSize() + sizeof(InlineDescriptor);
         if (std::numeric_limits<unsigned>::max() / ElemSize <= NumElems)
           return {};
-        return allocateDescriptor(D, ElemDesc, NumElems, IsConst, IsTemporary,
-                                  IsMutable);
+        return allocateDescriptor(D, ElemDesc, MDSize, NumElems, IsConst,
+                                  IsTemporary, IsMutable);
       }
     }
 
     // Array of unknown bounds - cannot be accessed and pointer arithmetic
     // is forbidden on pointers to such objects.
     if (isa<IncompleteArrayType>(ArrayType)) {
       if (std::optional<PrimType> T = Ctx.classify(ElemTy)) {
         return allocateDescriptor(D, *T, IsTemporary,
                                   Descriptor::UnknownSize{});
       } else {
-        Descriptor *Desc =
-            createDescriptor(D, ElemTy.getTypePtr(), IsConst, IsTemporary);
+        Descriptor *Desc = createDescriptor(D, ElemTy.getTypePtr(), MDSize,
+                                            IsConst, IsTemporary);
         if (!Desc)
           return nullptr;
         return allocateDescriptor(D, Desc, IsTemporary,
                                   Descriptor::UnknownSize{});
       }
     }
   }
 
   // Atomic types.
   if (auto *AT = Ty->getAs<AtomicType>()) {
     const Type *InnerTy = AT->getValueType().getTypePtr();
-    return createDescriptor(D, InnerTy, IsConst, IsTemporary, IsMutable);
+    return createDescriptor(D, InnerTy, MDSize, IsConst, IsTemporary,
+                            IsMutable);
   }
 
   // Complex types - represented as arrays of elements.
   if (auto *CT = Ty->getAs<ComplexType>()) {
     PrimType ElemTy = *Ctx.classify(CT->getElementType());
-    return allocateDescriptor(D, ElemTy, 2, IsConst, IsTemporary, IsMutable);
+    return allocateDescriptor(D, ElemTy, MDSize, 2, IsConst, IsTemporary,
+                              IsMutable);
   }
 
   return nullptr;
 }

clang/test/AST/Interp/cxx20.cpp

constexpr int pointerAssign2() {
   **pp = 12;
 
   int v = **pp;
 
   return v;
 }
 static_assert(pointerAssign2() == 12, "");
 
-
 constexpr int unInitLocal() {
   int a;
-  return a; // ref-note{{read of uninitialized object}}
-}
-static_assert(unInitLocal() == 0, ""); // expected-error {{not an integral constant expression}} \
-                                       // ref-error {{not an integral constant expression}} \
-                                       // ref-note {{in call to 'unInitLocal()'}}
+  return a; // ref-note {{read of uninitialized object}} \
+            // expected-note {{read of object outside its lifetime}}
+            // FIXME: ^^^ Wrong diagnostic.
+}
+static_assert(unInitLocal() == 0, ""); // ref-error {{not an integral constant expression}} \
+                                       // ref-note {{in call to 'unInitLocal()'}} \
+                                       // expected-error {{not an integral constant expression}} \
+                                       // expected-note {{in call to 'unInitLocal()'}} \
 
-/// TODO: The example above is correctly rejected by the new constexpr
-///   interpreter, but for the wrong reasons. We don't reject it because
-///   it is an uninitialized read, we reject it simply because
-///   the local variable does not have an initializer.
-///
-///   The code below should be accepted but is also being rejected
-///   right now.
-#if 0
 constexpr int initializedLocal() {
   int a;
-  int b;
-
   a = 20;
   return a;
 }
 static_assert(initializedLocal() == 20);
 
-/// Similar here, but the uninitialized local is passed as a function parameter.
+constexpr int initializedLocal2() {
+  int a[2];
+  return *a; // expected-note {{read of object outside its lifetime}} \
+             // ref-note {{read of uninitialized object is not allowed in a constant expression}}
+}
+static_assert(initializedLocal2() == 20); // expected-error {{not an integral constant expression}} \
+                                          // expected-note {{in call to}} \
+                                          // ref-error {{not an integral constant expression}} \
+                                          // ref-note {{in call to}}
+
+
+struct Int { int a; };
+constexpr int initializedLocal3() {
+  Int i;
+  return i.a; // expected-note {{read of object outside its lifetime}} \
+              // ref-note {{read of uninitialized object is not allowed in a constant expression}}
+}
+static_assert(initializedLocal3() == 20); // expected-error {{not an integral constant expression}} \
+                                          // expected-note {{in call to}} \
+                                          // ref-error {{not an integral constant expression}} \
+                                          // ref-note {{in call to}}
+
+
+
+#if 0
+// FIXME: This code should be rejected because we pass an uninitialized value
+//   as a function parameter.
 constexpr int inc(int a) { return a + 1; }
 constexpr int f() {
     int i;
     return inc(i);
 }
 static_assert(f());
 #endif
 

clang/test/AST/Interp/literals.cpp

namespace IncDec {
 
   constexpr int uninit() {
     int a;
     ++a; // ref-note {{increment of uninitialized}} \
          // FIXME: Should also be rejected by new interpreter
     return 1;
   }
   static_assert(uninit(), ""); // ref-error {{not an integral constant expression}} \
-                               // ref-note {{in call to 'uninit()'}} \
-                               // expected-error {{not an integral constant expression}}
+                               // ref-note {{in call to 'uninit()'}}
 
   constexpr int OverFlow() { // ref-error {{never produces a constant expression}}
     int a = INT_MAX;
     ++a; // ref-note 2{{is outside the range}} \
          // expected-note {{is outside the range}}
     return -1;
   }
   static_assert(OverFlow() == -1, "");  // expected-error {{not an integral constant expression}} \

clang/test/AST/Interp/loops.cpp

 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -std=c++14 -verify %s
 // RUN: %clang_cc1 -std=c++14 -verify=ref %s
 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -std=c++20 -verify=expected-cpp20 %s
 // RUN: %clang_cc1 -std=c++20 -verify=ref %s
 
 // ref-no-diagnostics
 // expected-no-diagnostics
+// expected-cpp20-no-diagnostics
 
 namespace WhileLoop {
   constexpr int f() {
     int i = 0;
     while(false) {
       i = i + 1;
     }
     return i;
do {
       continue;
     } while(true);
 
     return i;
   }
   static_assert(f5(true) == 8, "");
   static_assert(f5(false) == 5, "");
 
-  /// FIXME: This should be accepted in C++20 but is currently being rejected
-  ///   because the variable declaration doesn't have an initializier.
 #if __cplusplus >= 202002L
   constexpr int f6() {
     int i;
     do {
       i = 5;
       break;
     } while (true);
     return i;
   }
-  static_assert(f6() == 5, ""); // expected-cpp20-error {{not an integral constant}}
+  static_assert(f6() == 5, "");
 #endif
 
 #if 0
   /// FIXME: This is an infinite loop, which should
   ///   be rejected.
   constexpr int f7() {
     while(true);
   }