[clang][Interp] Implement array initializers and subscript expressions

[tbaeder]

Summary

It took me a pretty long time to get the patch this clean (and working), but here it is.

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

562

I've been wondering about a macro to simplify code like this, e.g. define DOIT(x) if(!x) return false; that I could instead define to assert(x) during development.

clang/test/AST/Interp/arrays.cpp

56

This is quite unfortunate, but it only fails when evaluating data[0] by itself, when printing the extra info for the failed static_assert. I roughly know what the problem is though.

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.h

53

Yes, a few of these cleanups, renames and added doc comments aren't necessary for this patch. I will remove them if you want to, I just don't want to rebase against main all the time to push NFC patches.

[tbaeder]

clang/test/AST/Interp/arrays.cpp

56

Ignore this, I fixed it.

[erichkeane]

Nothing suspicious as far as I can tell, other than just punting on ArrayFillers. Don't understand enough of this code to just do a straight-up approval though, so hopefully one of the other reviewers can take a look and confirm with another uninformed opinion :)

clang/lib/AST/Interp/ByteCodeExprGen.cpp

544

Heh, THIS is a huge "TODO" here. The ArrayFillers go through a ton of twists/turns in the current interpreter, as array-filler initializers can be massive. Do we have a way to avoid allocating space for filled-but-not-referenced values in this interpreter?

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

544

Heh, believe me, I know ;) I'd have to look into that, but I'm pretty sure the code as it is right now doesn't handle them at all.

[aaron.ballman]

Precommit CI found a relevant failure:

FAIL: Clang :: AST/Interp/arrays.cpp (67 of 15858)
******************** TEST 'Clang :: AST/Interp/arrays.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   c:\ws\w5\llvm-project\premerge-checks\build\bin\clang.exe -cc1 -internal-isystem c:\ws\w5\llvm-project\premerge-checks\build\lib\clang\16.0.0\include -nostdsysteminc -fexperimental-new-constant-interpreter -verify C:\ws\w5\llvm-project\premerge-checks\clang\test\AST\Interp\arrays.cpp
: 'RUN: at line 2';   c:\ws\w5\llvm-project\premerge-checks\build\bin\clang.exe -cc1 -internal-isystem c:\ws\w5\llvm-project\premerge-checks\build\lib\clang\16.0.0\include -nostdsysteminc -verify=ref C:\ws\w5\llvm-project\premerge-checks\clang\test\AST\Interp\arrays.cpp
--
Exit Code: 1

Command Output (stdout):
--
$ ":" "RUN: at line 1"
$ "c:\ws\w5\llvm-project\premerge-checks\build\bin\clang.exe" "-cc1" "-internal-isystem" "c:\ws\w5\llvm-project\premerge-checks\build\lib\clang\16.0.0\include" "-nostdsysteminc" "-fexperimental-new-constant-interpreter" "-verify" "C:\ws\w5\llvm-project\premerge-checks\clang\test\AST\Interp\arrays.cpp"
# command stderr:
error: 'note' diagnostics expected but not seen: 
  File C:\ws\w5\llvm-project\premerge-checks\clang\test\AST\Interp\arrays.cpp Line 49: 5 == 4
1 error generated.

error: command failed with exit status: 1

--

********************

clang/lib/AST/Interp/ByteCodeExprGen.h

53

Please remove them; we want to keep changes logically separate per our developer policy. The biggest reason is: we sometimes need to revert changes and there's no reason to lose the good (unrelated) work at the same time, but also, it helps code reviewers to focus on the important parts without getting lost tracking which changes are for what reason.

clang/test/AST/Interp/arrays.cpp

10

I'd like to see a test for designated initialization of arrays, including reinitialization: https://godbolt.org/z/xfjW8xPfE

[tbaeder]

In D132727#3755571, @aaron.ballman wrote:

Precommit CI found a relevant failure:

That needs the lvalue-to-rvalue conversion patch first.

[aaron.ballman]

In D132727#3755843, @tbaeder wrote:

In D132727#3755571, @aaron.ballman wrote:

Precommit CI found a relevant failure:

That needs the lvalue-to-rvalue conversion patch first.

Ah, good to know!

FWIW, one concern I've been pondering is building the new constant expression interpreter in such a way that we're working on higher-level constructs before having the lower-level constructs supported. I worry we're going to miss test coverage because we won't be able to add it until some later changes come in and then we'll forget to go back and add it. There's nothing specific to this review (nor actionable here), but just something to keep in mind as you're working on stuff. Implementing things like the type system (lvalue references, rvalue references, etc) first and then building other layers on top of that (like function calls, variables, etc) when plausible would ease those concerns.

clang/test/AST/Interp/arrays.cpp

41–44

A similar test we might want to add (whenever we get around to references):

template <typename T, int N>
constexpr T& getElementOf(T (&array)[N], int I) {
  return array[I];
}
static_assert(getElementOf(foo[2], 3) == &m, "");

[tbaeder]

clang/test/AST/Interp/arrays.cpp

41–44

I added that to https://reviews.llvm.org/D132997

[aaron.ballman]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

277

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

246

256

You can drop this else because of the preceding unconditional return.

258

260

You should drop this else as well.

clang/lib/AST/Interp/Pointer.cpp

158

isArray() already covers isPrimitiveArray() so this change looks unnecessary.

[aaron.ballman]

LGTM!

[MaskRay]

Heads-up: after D132832 and D132727, clang/test/AST/Interp/arrays.cpp.test has a msan failure. It can be pre-existing or can be newly introduced.
There seems another issue about an integer overflow in InitMap::isInitialized.

Still investigating.

[tbaeder]

Thanks @MaskRay, I thought this was fixed by https://github.com/llvm/llvm-project/commit/86271798e51a7866dd2af44e0ee183d1331089e6, at least all the emails I got about failing msan builds were missing that change.

[MaskRay]

In D132727#3779237, @tbaeder wrote:

Thanks @MaskRay, I thought this was fixed by https://github.com/llvm/llvm-project/commit/86271798e51a7866dd2af44e0ee183d1331089e6, at least all the emails I got about failing msan builds were missing that change.

For a msan failure of llvm/clang/test/AST/Interp/arrays.cpp, I have verified that only after 49c289879c7aa9737429f7342c7149a8ba958667 it is fixed:)

clang/lib/AST/Interp/ByteCodeExprGen.h

protected:
   using UnaryFn = bool (ByteCodeExprGen::*)(PrimType, const SourceInfo &);
   using BinaryFn = bool (ByteCodeExprGen::*)(PrimType, PrimType,
                                              const SourceInfo &);
 
   // Aliases for types defined in the emitter.
   using LabelTy = typename Emitter::LabelTy;
   using AddrTy = typename Emitter::AddrTy;
 
   // Reference to a function generating the pointer of an initialized object.s
   using InitFnRef = std::function<bool()>;
 
   /// Current compilation context.
   Context &Ctx;
   /// Program to link to.
   Program &P;
 
 public:
   /// Initializes the compiler and the backend emitter.
   template <typename... Tys>
   ByteCodeExprGen(Context &Ctx, Program &P, Tys &&... Args)
       : Emitter(Ctx, P, Args...), Ctx(Ctx), P(P) {}
 
-  // Expression visitors - result returned on stack.
+  // Expression visitors - result returned on interp stack.
   bool VisitCastExpr(const CastExpr *E);
   bool VisitIntegerLiteral(const IntegerLiteral *E);
   bool VisitParenExpr(const ParenExpr *E);
   bool VisitBinaryOperator(const BinaryOperator *E);
   bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E);
   bool VisitCallExpr(const CallExpr *E);
   bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E);
   bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E);
   bool VisitUnaryOperator(const UnaryOperator *E);
   bool VisitDeclRefExpr(const DeclRefExpr *E);
   bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E);
   bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E);
+  bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
+  bool VisitInitListExpr(const InitListExpr *E);
+  bool VisitConstantExpr(const ConstantExpr *E);
 
 protected:
   bool visitExpr(const Expr *E) override;
   bool visitDecl(const VarDecl *VD) override;
 
 protected:
   /// Emits scope cleanup instructions.
   void emitCleanup();
PrimType classifyPrim(QualType Ty) const {
     }
     llvm_unreachable("not a primitive type");
   }
 
   /// Evaluates an expression for side effects and discards the result.
   bool discard(const Expr *E);
   /// Evaluates an expression and places result on stack.
   bool visit(const Expr *E);
-  /// Compiles an initializer for a local.
-  bool visitInitializer(const Expr *E, InitFnRef GenPtr);
+  /// Compiles an initializer.
+  bool visitInitializer(const Expr *E);
+  /// Compiles an array initializer.
+  bool visitArrayInitializer(const Expr *Initializer);
 
   /// Visits an expression and converts it to a boolean.
   bool visitBool(const Expr *E);
 
   /// Visits an initializer for a local.
   bool visitLocalInitializer(const Expr *Init, unsigned I) {
-    return visitInitializer(Init, [this, I, Init] {
-      return this->emitGetPtrLocal(I, Init);
-    });
+    if (!this->emitGetPtrLocal(I, Init))
+      return false;
+
+    if (!visitInitializer(Init))
+      return false;
+
+    return this->emitPopPtr(Init);
   }
 
   /// Visits an initializer for a global.
   bool visitGlobalInitializer(const Expr *Init, unsigned I) {
-    return visitInitializer(Init, [this, I, Init] {
-      return this->emitGetPtrGlobal(I, Init);
-    });
+    if (!this->emitGetPtrGlobal(I, Init))
+      return false;
+
+    if (!visitInitializer(Init))
+      return false;
+
+    return this->emitPopPtr(Init);
   }
 
   /// Visits a delegated initializer.
   bool visitThisInitializer(const Expr *I) {
-    return visitInitializer(I, [this, I] { return this->emitThis(I); });
+    if (!this->emitThis(I))
+      return false;
+
+    if (!visitInitializer(I))
+      return false;
+
+    return this->emitPopPtr(I);
   }
 
   /// Creates a local primitive value.
   unsigned allocateLocalPrimitive(DeclTy &&Decl, PrimType Ty, bool IsMutable,
                                   bool IsExtended = false);
 
   /// Allocates a space storing a local given its type.
   llvm::Optional<unsigned> allocateLocal(DeclTy &&Decl,

clang/lib/AST/Interp/ByteCodeExprGen.cpp

 bool ByteCodeExprGen<Emitter>::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
   if (Optional<PrimType> T = classify(E))
     return this->emitZero(*T, E);
 
   return false;
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitArraySubscriptExpr(
+    const ArraySubscriptExpr *E) {
+  const Expr *Base = E->getBase();
+  const Expr *Index = E->getIdx();
+
+  // Take pointer of LHS, add offset from RHS, narrow result.
+  // What's left on the stack after this is a pointer.
+  if (Optional<PrimType> IndexT = classify(Index->getType())) {
+    if (!this->Visit(Base))
+      return false;
+
+    if (!this->Visit(Index))
+      return false;
+
+    if (!this->emitAddOffset(*IndexT, E))
+      return false;
+
+    if (!this->emitNarrowPtr(E))
+      return false;
+
+    return true;
+  }
+
+  return false;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitInitListExpr(const InitListExpr *E) {
+  for (const Expr *Init : E->inits()) {
+    if (!this->visit(Init))
+      return false;
+  }
+  return true;
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitSubstNonTypeTemplateParmExpr(
     const SubstNonTypeTemplateParmExpr *E) {
   return this->visit(E->getReplacement());
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitConstantExpr (const ConstantExpr *E) {
+  // TODO: Check if the ConstantExpr already has a value set and if so,
+  //   use that instead of evaluating it again.
+  return this->visit(E->getSubExpr());
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
   OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/true);
   return this->Visit(E);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visit(const Expr *E) {
   OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/false);
ByteCodeExprGen<Emitter>::allocateLocal(DeclTy &&Src, bool IsExtended) {
 
   Scope::Local Local = this->createLocal(D);
   if (Key)
     Locals.insert({Key, Local});
   VarScope->add(Local, IsExtended);
   return Local.Offset;
 }
 
+// NB: When calling this function, we have a pointer to the
+//   array-to-initialize on the stack.
 template <class Emitter>
-bool ByteCodeExprGen<Emitter>::visitInitializer(
-    const Expr *Init, InitFnRef InitFn) {
-  OptionScope<Emitter> Scope(this, InitFn);
-  return this->Visit(Init);
+bool ByteCodeExprGen<Emitter>::visitArrayInitializer(const Expr *Initializer) {
+  assert(Initializer->getType()->isArrayType());
+
+  // TODO: Fillers?
+  if (const auto *InitList = dyn_cast<InitListExpr>(Initializer)) {
+    unsigned ElementIndex = 0;
+    for (const Expr *Init : InitList->inits()) {
+      QualType InitType = Init->getType();
+
+      if (InitType->isArrayType()) {
+        // Advance the pointer currently on the stack to the given
+        // dimension and narrow().
+        if (!this->emitDupPtr(Init))
+          return false;
+        if (!this->emitConstUint32(ElementIndex, Init))
+          return false;
+        if (!this->emitAddOffsetUint32(Init))
+          return false;
+        if (!this->emitNarrowPtr(Init))
+          return false;
+        if (!visitArrayInitializer(Init))
+          return false;
+        if (!this->emitPopPtr(Init))
+          return false;
+      } else if (Optional<PrimType> T = classify(InitType)) {
+        // Visit the primitive element like normal.
+        if (!this->visit(Init))
+          return false;
+        if (!this->emitInitElem(*T, ElementIndex, Init))
+          return false;
+      } else {
+        assert(false && "Unhandled type in array initializer initlist");
+      }
+
+      ++ElementIndex;
+    }
+
+  } else {
+    assert(false && "Unknown expression for array initialization");
+  }
+
+  return true;
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitInitializer(const Expr *Initializer) {
+  QualType InitializerType = Initializer->getType();
+
+  if (InitializerType->isArrayType())
+    return visitArrayInitializer(Initializer);
+
+  // Otherwise, visit the expression like normal.
+  return this->Visit(Initializer);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::getPtrVarDecl(const VarDecl *VD, const Expr *E) {
   // Generate a pointer to the local, loading refs.
   if (Optional<unsigned> Idx = getGlobalIdx(VD)) {
     if (VD->getType()->isReferenceType())
       return this->emitGetGlobalPtr(*Idx, E);

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

if (const Expr *RE = RS->getRetValue()) {
     if (ReturnType) {
       // Primitive types are simply returned.
       if (!this->visit(RE))
         return false;
       this->emitCleanup();
       return this->emitRet(*ReturnType, RS);
     } else {
       // RVO - construct the value in the return location.
-      auto ReturnLocation = [this, RE] { return this->emitGetParamPtr(0, RE); };
-      if (!this->visitInitializer(RE, ReturnLocation))
+      if (!this->visitInitializer(RE))
         return false;
       this->emitCleanup();
       return this->emitRetVoid(RS);
     }
   } else {
     this->emitCleanup();
     if (!this->emitRetVoid(RS))
       return false;
if (const Stmt *Else = IS->getElse()) {
     this->emitLabel(LabelEnd);
   }
 
   return true;
 }
 
 template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitVarDecl(const VarDecl *VD) {
-  auto DT = VD->getType();
-
   if (!VD->hasLocalStorage()) {
     // No code generation required.
     return true;
   }
 
   // Integers, pointers, primitives.
-  if (Optional<PrimType> T = this->classify(DT)) {
+  if (Optional<PrimType> T = this->classify(VD->getType())) {
     const Expr *Init = VD->getInit();
 
     if (!Init)
       return false;
 
-    auto Off = this->allocateLocalPrimitive(VD, *T, DT.isConstQualified());
+    auto Offset =
+        this->allocateLocalPrimitive(VD, *T, VD->getType().isConstQualified());
     // Compile the initializer in its own scope.
     {
       ExprScope<Emitter> Scope(this);
       if (!this->visit(Init))
         return false;
     }
     // Set the value.
-    return this->emitSetLocal(*T, Off, VD);
+    return this->emitSetLocal(*T, Offset, VD);
   } else {
     // Composite types - allocate storage and initialize it.
-    if (auto Off = this->allocateLocal(VD)) {
-      return this->visitLocalInitializer(VD->getInit(), *Off);
-    } else {
+    if (auto Offset = this->allocateLocal(VD))
+      return this->visitLocalInitializer(VD->getInit(), *Offset);
+    else
       return this->bail(VD);
-    }
-  }
-}
 
 namespace clang {
 namespace interp {
 
 template class ByteCodeStmtGen<ByteCodeEmitter>;
 
 } // namespace interp
 } // namespace clang

clang/lib/AST/Interp/Interp.h

bool InitPop(InterpState &S, CodePtr OpPC) {
   const Pointer &Ptr = S.Stk.pop<Pointer>();
   if (!CheckInit(S, OpPC, Ptr))
     return false;
   Ptr.initialize();
   new (&Ptr.deref<T>()) T(Value);
   return true;
 }
 
+/// 1) Pops the value from the stack
+/// 2) Peeks a pointer and gets its index \Idx
+/// 3) Sets the value on the pointer, leaving the pointer on the stack.
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool InitElem(InterpState &S, CodePtr OpPC, uint32_t Idx) {
   const T &Value = S.Stk.pop<T>();
   const Pointer &Ptr = S.Stk.peek<Pointer>().atIndex(Idx);
   if (!CheckInit(S, OpPC, Ptr))
     return false;
   Ptr.initialize();
   new (&Ptr.deref<T>()) T(Value);
   return true;
 }
 
+/// The same as InitElem, but pops the pointer as well.
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool InitElemPop(InterpState &S, CodePtr OpPC, uint32_t Idx) {
   const T &Value = S.Stk.pop<T>();
   const Pointer &Ptr = S.Stk.pop<Pointer>().atIndex(Idx);
   if (!CheckInit(S, OpPC, Ptr))
     return false;
   Ptr.initialize();
   new (&Ptr.deref<T>()) T(Value);

clang/lib/AST/Interp/Pointer.cpp

if (isUnknownSizeArray()) {
       IsOnePastEnd = false;
       Offset = CharUnits::Zero();
     } else {
       // TODO: compute the offset into the object.
       Offset = CharUnits::Zero();
 
       // Build the path into the object.
       Pointer Ptr = *this;
-      while (Ptr.isField()) {
+      while (Ptr.isField() || Ptr.isArrayElement()) {
         if (Ptr.isArrayElement()) {
           Path.push_back(APValue::LValuePathEntry::ArrayIndex(Ptr.getIndex()));
           Ptr = Ptr.getArray();
         } else {
           // TODO: figure out if base is virtual
           bool IsVirtual = false;
 
           // Create a path entry for the field.
if (Desc->isPrimitiveArray()) {
     // Field has its bit in an inline descriptor.
     return Base == 0 || getInlineDesc()->IsInitialized;
   }
 }
 
 void Pointer::initialize() const {
   assert(Pointee && "Cannot initialize null pointer");
   Descriptor *Desc = getFieldDesc();
-  if (Desc->isPrimitiveArray()) {
+
+  if (Desc->isArray() || Desc->isPrimitiveArray()) {
     if (!Pointee->IsStatic) {
       // Primitive array initializer.
       InitMap *&Map = getInitMap();
       if (Map == (InitMap *)-1)
         return;
       if (Map == nullptr)
         Map = InitMap::allocate(Desc->getNumElems());
       if (Map->initialize(getIndex())) {

clang/lib/AST/Interp/Program.cpp

if (auto CAT = dyn_cast<ConstantArrayType>(ArrayType)) {
         if (std::numeric_limits<unsigned>::max() / ElemSize <= NumElems) {
           return {};
         }
         return allocateDescriptor(D, *T, NumElems, IsConst, IsTemporary,
                                   IsMutable);
       } else {
         // Arrays of composites. In this case, the array is a list of pointers,
         // followed by the actual elements.
-        Descriptor *Desc =
+        Descriptor *ElemDesc =
             createDescriptor(D, ElemTy.getTypePtr(), IsConst, IsTemporary);
-        if (!Desc)
+        if (!ElemDesc)
           return nullptr;
-        InterpSize ElemSize = Desc->getAllocSize() + sizeof(InlineDescriptor);
+        InterpSize ElemSize =
+            ElemDesc->getAllocSize() + sizeof(InlineDescriptor);
         if (std::numeric_limits<unsigned>::max() / ElemSize <= NumElems)
           return {};
-        return allocateDescriptor(D, Desc, NumElems, IsConst, IsTemporary,
+        return allocateDescriptor(D, ElemDesc, 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 (llvm::Optional<PrimType> T = Ctx.classify(ElemTy)) {

clang/test/AST/Interp/arrays.cpp

 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify %s
 // RUN: %clang_cc1 -verify=ref %s
 
+constexpr int m = 3;
+constexpr const int *foo[][5] = {
+  {nullptr, &m, nullptr, nullptr, nullptr},
+  {nullptr, nullptr, &m, nullptr, nullptr},
+  {nullptr, nullptr, nullptr, &m, nullptr},
+};
+
+static_assert(foo[0][0] == nullptr, "");
+static_assert(foo[0][1] == &m, "");
+static_assert(foo[0][2] == nullptr, "");
+static_assert(foo[0][3] == nullptr, "");
+static_assert(foo[0][4] == nullptr, "");
+static_assert(foo[1][0] == nullptr, "");
+static_assert(foo[1][1] == nullptr, "");
+static_assert(foo[1][2] == &m, "");
+static_assert(foo[1][3] == nullptr, "");
+static_assert(foo[1][4] == nullptr, "");
+static_assert(foo[2][0] == nullptr, "");
+static_assert(foo[2][1] == nullptr, "");
+static_assert(foo[2][2] == nullptr, "");
+static_assert(foo[2][3] == &m, "");
+static_assert(foo[2][4] == nullptr, "");
+
+
+/// A init list for a primitive value.
+constexpr int f{5};
+static_assert(f == 5, "");
+
+
+constexpr int getElement(int i) {
+  int values[] = {1, 4, 9, 16, 25, 36};
+  return values[i];
+}
+static_assert(getElement(1) == 4, "");
+static_assert(getElement(5) == 36, "");
+
+
+template<typename T>
+constexpr T getElementOf(T* array, int i) {
+  return array[i];
+}
+static_assert(getElementOf(foo[0], 1) == &m, "");
+
 
-/// expected-no-diagnostics
-/// ref-no-diagnostics
+constexpr int data[] = {5, 4, 3, 2, 1};
+static_assert(data[0] == 4, ""); // expected-error{{failed}} \
+                                 // expected-note{{5 == 4}} \
+                                 // ref-error{{failed}} \
+                                 // ref-note{{5 == 4}}
+
+
+constexpr int dynamic[] = {
+  f, 3, 2 + 5, data[3], *getElementOf(foo[2], 3)
+};
+static_assert(dynamic[0] == f, "");
+static_assert(dynamic[3] == 2, "");
+
+
+constexpr int dependent[4] = {
+  0, 1, dependent[0], dependent[1]
+};
+static_assert(dependent[2] == dependent[0], "");
+static_assert(dependent[3] == dependent[1], "");
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wc99-extensions"
 #pragma clang diagnostic ignored "-Winitializer-overrides"
+constexpr int DI[] = {
+  [0] = 10,
+  [1] = 20,
+  30,
+  40,
+  [1] = 50
+};
+static_assert(DI[0] == 10, "");
+static_assert(DI[1] == 50, "");
+static_assert(DI[2] == 30, "");
+static_assert(DI[3] == 40, "");
+
 /// FIXME: The example below tests ImplicitValueInitExprs, but we can't
 ///   currently evaluate other parts of it.
 #if 0
 struct fred {
   char s [6];
   int n;
 };
 
 struct fred y [] = { [0] = { .s[0] = 'q' } };
 #endif
 #pragma clang diagnostic pop