[clang][Interp] Fix getIndex() for composite array elements

[cor3ntin]

clang/lib/AST/Interp/Context.h

90

This should return a const ref

clang/lib/AST/Interp/Pointer.h

220

WS only change

340

Can you be a bit more verbose here? I can't figure out what is happening from the comment!

[tbaeder]

clang/lib/AST/Interp/Context.h

90

Things like getGlobal() aren't const so that doesn't work.

clang/lib/AST/Interp/Pointer.h

340

For primitive arrays, the elements don't have inline descriptors:

                     Offset
                     │
                     ▼
┌────────┬───┬───┬───┬───┬───┬─────┐
│InitMap │ 1 │ 2 │ 3 │ 4 │ 5 │ ... │
└────────┴───┴───┴───┴───┴───┴─────┘
▲
│
Base

If the array elements are composite elements themselves however, we can have a pointer that refers to the array element:

               Offset
               │
               ▼
┌──────────┬───┬──────────┬───┐
│InlineDesc│'a'│InlineDesc│'b'│
└──────────┴───┴──────────┴───┘
▲
│
Base

(so things like isArrayElement() return true) as well as a pointer that _only_ refers to the composite element (after a call to narrow():

               Offset
               │
               ▼
┌──────────┬───┬──────────┬───┐
│InlineDesc│'a'│InlineDesc│'b'│
└──────────┴───┴──────────┴───┘
               ▲
               │
               Base

For the latter, the expected value of getIndex() is 0, since it is (as far as the pointer knows) _not_ an array element.

[tbaeder]

Ping

[aaron.ballman]

clang/lib/AST/Interp/Context.h

90

If this is only needed for testing, can we make it a private function and use friendship to expose it to just what needs it? (Esp because it's got some odd const-correctness properties to it.)

clang/lib/AST/Interp/Pointer.h

81–88

Same here -- can these be private and friended?

[tbaeder]

clang/lib/AST/Interp/Pointer.h

81–88

Don't you need a class to friend something? I only have the TEST(...) function in the unit test, so I can't do that, right?

[aaron.ballman]

clang/lib/AST/Interp/Pointer.h

81–88

FRIEND_TEST does this, I believe: https://google.github.io/googletest/reference/testing.html#FRIEND_TEST

[tbaeder]

clang/lib/AST/Interp/Pointer.h

81–88

Is this something we should be doing? There's nothing else in clang using FRIEND_TEST and only stuff in Testing/ includes gtest.h.

[aaron.ballman]

clang/lib/AST/Interp/Pointer.h

81–88

It's a tradeoff as to whether we want to expose private implementation details as part of a public interface just to enable unit testing, or whether we want to sprinkle unit testing annotations around the private implementation details just to enable unit testing. Personally, I prefer having cleaner public interfaces; otherwise we end up with people using the implementation details of a class and it's harder to refactor in the future. I'm not certain how others feel, though.

[tbaeder]

clang/lib/AST/Interp/Pointer.h

81–88

I think FRIEND_TEST just doesn't work because I can't import a gtest header from the clangAST library.

What I can do is just wrap those things in a #ifdef IN_UNITTEST and define than before including those headers (all of this code is in headers right now) in the unittest/AST/Interp/Descriptor.cpp.

[aaron.ballman]

clang/lib/AST/Interp/Pointer.h

81–88

Okay, that seems like a good compromise to me. Later, we might want to figure out if we can hoist the macro logic up to a higher level so that other interfaces can use the same pattern. (e.g., maybe we want LLVM_UNIT_TEST_INTERFACE macro or some such?)

[aaron.ballman]

LGTM!

[thakis]

clang/unittests/AST/Interp/CMakeLists.txt

2

Why is this in a separate executable instead of in ASTTests? So it can have fewer deps?

[tbaeder]

clang/unittests/AST/Interp/CMakeLists.txt

2

Mostly because running ASTTests takes very long

clang/lib/AST/Interp/Context.h

public:
   /// given ValueDecl.
   static bool shouldBeGloballyIndexed(const ValueDecl *VD) {
     if (const auto *V = dyn_cast<VarDecl>(VD))
       return V->hasGlobalStorage() || V->isConstexpr();
 
     return false;
   }
 
+  /// Returns the program. This is only needed for unittests.
+  Program &getProgram() const { return *P.get(); }
+
 private:
   /// Runs a function.
   bool Run(State &Parent, const Function *Func, APValue &Result);
 
   /// Checks a result from the interpreter.
   bool Check(State &Parent, llvm::Expected<bool> &&R);
 
   /// Current compilation context.

clang/lib/AST/Interp/Pointer.h

public:
   Pointer(Block *B, unsigned BaseAndOffset);
   Pointer(const Pointer &P);
   Pointer(Pointer &&P);
   ~Pointer();
 
   void operator=(const Pointer &P);
   void operator=(Pointer &&P);
 
+  /// Equality operators are just for tests.
+  bool operator==(const Pointer &P) const {
+    return Pointee == P.Pointee && Base == P.Base && Offset == P.Offset;
+  }
+
+  bool operator!=(const Pointer &P) const {
+    return Pointee != P.Pointee || Base != P.Base || Offset != P.Offset;
+  }
+
   /// Converts the pointer to an APValue.
   APValue toAPValue() const;
 
   /// Converts the pointer to a string usable in diagnostics.
   std::string toDiagnosticString(const ASTContext &Ctx) const;
 
   unsigned getIntegerRepresentation() const {
     return reinterpret_cast<uintptr_t>(Pointee) + Offset;
[[nodiscard]] Pointer getBase() const {
     return Pointer(Pointee, NewBase, NewBase);
   }
   /// Returns the parent array.
   [[nodiscard]] Pointer getArray() const {
     if (Base == RootPtrMark) {
       assert(Offset != 0 && Offset != PastEndMark && "not an array element");
       return Pointer(Pointee, Base, 0);
     }
     assert(Offset != Base && "not an array element");
     return Pointer(Pointee, Base, Base);
   }
 
   /// Accessors for information about the innermost field.
   Descriptor *getFieldDesc() const {
     if (Base == 0 || Base == RootPtrMark)
       return getDeclDesc();
     return getInlineDesc()->Desc;
public:
   bool isRoot() const {
     return (Base == 0 || Base == RootPtrMark) && Offset == 0;
   }
 
   /// Returns the record descriptor of a class.
   const Record *getRecord() const { return getFieldDesc()->ElemRecord; }
   /// Returns the element record type, if this is a non-primive array.
   const Record *getElemRecord() const {
-    return getFieldDesc()->ElemDesc->ElemRecord;
+    const Descriptor *ElemDesc = getFieldDesc()->ElemDesc;
+    return ElemDesc ? ElemDesc->ElemRecord : nullptr;
   }
   /// Returns the field information.
   const FieldDecl *getField() const { return getFieldDesc()->asFieldDecl(); }
 
   /// Checks if the object is a union.
   bool isUnion() const;
 
   /// Checks if the storage is extern.
public:
   unsigned getNumElems() const { return getSize() / elemSize(); }
 
   const Block *block() const { return Pointee; }
 
   /// Returns the index into an array.
   int64_t getIndex() const {
     if (isElementPastEnd())
       return 1;
+
+    // narrow()ed element in a composite array.
+    if (Base > 0 && Base == Offset)
+      return 0;
+
     if (auto ElemSize = elemSize())
       return getOffset() / ElemSize;
     return 0;
   }
 
   /// Checks if the index is one past end.
   bool isOnePastEnd() const {
     return isElementPastEnd() || getSize() == getOffset();

clang/unittests/AST/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   TargetParser
   )
 
 
+add_subdirectory(Interp)
+
 add_clang_unittest(ASTTests
   ASTContextParentMapTest.cpp
   ASTExprTest.cpp
   ASTImporterFixtures.cpp
   ASTImporterTest.cpp
   ASTImporterObjCTest.cpp
   ASTImporterGenericRedeclTest.cpp
   ASTImporterODRStrategiesTest.cpp

clang/unittests/AST/Interp/CMakeLists.txt

+add_clang_unittest(InterpTests
+  Descriptor.cpp
+  )
+
+clang_target_link_libraries(InterpTests
+  PRIVATE
+  clangAST
+  clangBasic
+  )
+
+  target_link_libraries(InterpTests
+  PRIVATE
+  clangTesting
+)

clang/unittests/AST/Interp/Descriptor.cpp

+#include "../../../lib/AST/Interp/Descriptor.h"
+#include "../../../lib/AST/Interp/Context.h"
+#include "../../../lib/AST/Interp/Program.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Tooling/Tooling.h"
+#include "gtest/gtest.h"
+
+using namespace clang;
+using namespace clang::interp;
+using namespace clang::ast_matchers;
+
+/// Inspect generated Descriptors as well as the pointers we create.
+///
+TEST(Descriptor, Primitives) {
+  constexpr char Code[] =
+      "struct A { bool a; bool b; };\n"
+      "struct S {\n"
+      "  float f;\n"
+      "  char s[4];\n"
+      "  A a[3];\n"
+      "  short l[3][3];\n"
+      "};\n"
+      "constexpr S d = {0.0, \"foo\", {{true, false}, {false, true}, {false, false}},\n"
+      "  {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}};\n";
+
+  auto AST = tooling::buildASTFromCodeWithArgs(
+      Code, {"-fexperimental-new-constant-interpreter"});
+
+  const VarDecl *D = selectFirst<VarDecl>(
+      "d", match(varDecl().bind("d"), AST->getASTContext()));
+  ASSERT_NE(D, nullptr);
+
+  const auto &Ctx = AST->getASTContext().getInterpContext();
+  Program &Prog = Ctx.getProgram();
+  // Global is registered.
+  ASSERT_TRUE(Prog.getGlobal(D));
+
+  // Get a Pointer to the global.
+  const Pointer &GlobalPtr = Prog.getPtrGlobal(*Prog.getGlobal(D));
+
+  // Test Descriptor of the struct S.
+  const Descriptor *GlobalDesc = GlobalPtr.getFieldDesc();
+  ASSERT_TRUE(GlobalDesc == GlobalPtr.getDeclDesc());
+
+  ASSERT_TRUE(GlobalDesc->asDecl() == D);
+  ASSERT_FALSE(GlobalDesc->asExpr());
+  ASSERT_TRUE(GlobalDesc->asValueDecl() == D);
+  ASSERT_FALSE(GlobalDesc->asFieldDecl());
+  ASSERT_FALSE(GlobalDesc->asRecordDecl());
+
+  // Still true because this is a global variable.
+  ASSERT_TRUE(GlobalDesc->getMetadataSize() == 0);
+  ASSERT_FALSE(GlobalDesc->isPrimitiveArray());
+  ASSERT_FALSE(GlobalDesc->isCompositeArray());
+  ASSERT_FALSE(GlobalDesc->isZeroSizeArray());
+  ASSERT_FALSE(GlobalDesc->isUnknownSizeArray());
+  ASSERT_FALSE(GlobalDesc->isPrimitive());
+  ASSERT_FALSE(GlobalDesc->isArray());
+  ASSERT_TRUE(GlobalDesc->isRecord());
+
+  // Test the Record for the struct S.
+  const Record *SRecord = GlobalDesc->ElemRecord;
+  ASSERT_TRUE(SRecord);
+  ASSERT_TRUE(SRecord->getNumFields() == 4);
+  ASSERT_TRUE(SRecord->getNumBases() == 0);
+  ASSERT_FALSE(SRecord->getDestructor());
+
+  // First field.
+  const Record::Field *F1 = SRecord->getField(0u);
+  ASSERT_TRUE(F1);
+  ASSERT_FALSE(F1->isBitField());
+  ASSERT_TRUE(F1->Desc->isPrimitive());
+
+  // Second field.
+  const Record::Field *F2 = SRecord->getField(1u);
+  ASSERT_TRUE(F2);
+  ASSERT_FALSE(F2->isBitField());
+  ASSERT_TRUE(F2->Desc->isArray());
+  ASSERT_FALSE(F2->Desc->isCompositeArray());
+  ASSERT_TRUE(F2->Desc->isPrimitiveArray());
+  ASSERT_FALSE(F2->Desc->isPrimitive());
+  ASSERT_FALSE(F2->Desc->ElemDesc);
+  ASSERT_EQ(F2->Desc->getNumElems(), 4u);
+  ASSERT_TRUE(F2->Desc->getElemSize() > 0);
+
+  // Third field.
+  const Record::Field *F3 = SRecord->getField(2u);
+  ASSERT_TRUE(F3);
+  ASSERT_FALSE(F3->isBitField());
+  ASSERT_TRUE(F3->Desc->isArray());
+  ASSERT_TRUE(F3->Desc->isCompositeArray());
+  ASSERT_FALSE(F3->Desc->isPrimitiveArray());
+  ASSERT_FALSE(F3->Desc->isPrimitive());
+  ASSERT_TRUE(F3->Desc->ElemDesc);
+  ASSERT_EQ(F3->Desc->getNumElems(), 3u);
+  ASSERT_TRUE(F3->Desc->getElemSize() > 0);
+
+  // Fourth field.
+  // Multidimensional arrays are treated as composite arrays, even
+  // if the value type is primitive.
+  const Record::Field *F4 = SRecord->getField(3u);
+  ASSERT_TRUE(F4);
+  ASSERT_FALSE(F4->isBitField());
+  ASSERT_TRUE(F4->Desc->isArray());
+  ASSERT_TRUE(F4->Desc->isCompositeArray());
+  ASSERT_FALSE(F4->Desc->isPrimitiveArray());
+  ASSERT_FALSE(F4->Desc->isPrimitive());
+  ASSERT_TRUE(F4->Desc->ElemDesc);
+  ASSERT_EQ(F4->Desc->getNumElems(), 3u);
+  ASSERT_TRUE(F4->Desc->getElemSize() > 0);
+  ASSERT_TRUE(F4->Desc->ElemDesc->isPrimitiveArray());
+
+  // Check pointer stuff.
+  // Global variables have no inline descriptor (yet).
+  ASSERT_TRUE(GlobalPtr.isRoot());
+  ASSERT_TRUE(GlobalPtr.isLive());
+  ASSERT_FALSE(GlobalPtr.isZero());
+  ASSERT_FALSE(GlobalPtr.isField());
+  ASSERT_TRUE(GlobalPtr.getFieldDesc() == GlobalPtr.getDeclDesc());
+  ASSERT_TRUE(GlobalPtr.getOffset() == 0);
+  ASSERT_FALSE(GlobalPtr.inArray());
+  ASSERT_FALSE(GlobalPtr.isArrayElement());
+  ASSERT_FALSE(GlobalPtr.isArrayRoot());
+  ASSERT_FALSE(GlobalPtr.inPrimitiveArray());
+  ASSERT_TRUE(GlobalPtr.isStatic());
+  ASSERT_TRUE(GlobalPtr.isInitialized());
+  ASSERT_FALSE(GlobalPtr.isOnePastEnd());
+  ASSERT_FALSE(GlobalPtr.isElementPastEnd());
+
+  // Pointer to the first field (a primitive).
+  const Pointer &PF1 = GlobalPtr.atField(F1->Offset);
+  ASSERT_TRUE(PF1.isLive());
+  ASSERT_TRUE(PF1.isInitialized());
+  ASSERT_TRUE(PF1.isField());
+  ASSERT_FALSE(PF1.inArray());
+  ASSERT_FALSE(PF1.isArrayElement());
+  ASSERT_FALSE(PF1.isArrayRoot());
+  ASSERT_FALSE(PF1.isOnePastEnd());
+  ASSERT_FALSE(PF1.isRoot());
+  ASSERT_TRUE(PF1.getFieldDesc()->isPrimitive());
+  ASSERT_TRUE(Pointer::hasSameBase(PF1, GlobalPtr));
+  ASSERT_TRUE(PF1.getBase() == GlobalPtr);
+
+  // Pointer to the second field (a primitive array).
+  const Pointer &PF2 = GlobalPtr.atField(F2->Offset);
+  ASSERT_TRUE(PF2.isLive());
+  ASSERT_TRUE(PF2.isInitialized());
+  ASSERT_TRUE(PF2.isField());
+  ASSERT_TRUE(PF2.inArray());
+  ASSERT_FALSE(PF2.isArrayElement());
+  ASSERT_TRUE(PF2.isArrayRoot());
+  ASSERT_TRUE(PF2.getNumElems() == 4);
+  ASSERT_FALSE(PF2.isOnePastEnd());
+  ASSERT_FALSE(PF2.isRoot());
+  ASSERT_FALSE(PF2.getFieldDesc()->isPrimitive());
+  ASSERT_TRUE(PF2.getFieldDesc()->isArray());
+  ASSERT_TRUE(Pointer::hasSameBase(PF2, GlobalPtr));
+  ASSERT_TRUE(PF2.getBase() == GlobalPtr);
+
+  // Check contents of field 2 (a primitive array).
+  {
+    const Pointer &E1 = PF2.atIndex(0);
+    ASSERT_TRUE(E1.isLive());
+    ASSERT_FALSE(E1.isArrayRoot());
+    ASSERT_TRUE(E1.isArrayElement());
+    ASSERT_TRUE(E1.inPrimitiveArray());
+    ASSERT_TRUE(E1.deref<char>() == 'f');
+    ASSERT_EQ(E1.getIndex(), 0u);
+    ASSERT_TRUE(E1 == E1.atIndex(0));
+    ASSERT_TRUE(Pointer::hasSameBase(E1, GlobalPtr));
+
+    const Pointer &E2 = PF2.atIndex(1);
+    ASSERT_TRUE(E2.isLive());
+    ASSERT_FALSE(E2.isArrayRoot());
+    ASSERT_TRUE(E2.isArrayElement());
+    ASSERT_EQ(E2.getIndex(), 1u);
+    // Narrow() doesn't do anything on primitive array elements, as there is
+    // nothing to narrow into.
+    ASSERT_EQ(E2.narrow(), E2);
+    // ... so this should also hold.
+    ASSERT_EQ(E2.expand(), E2);
+    ASSERT_EQ(E2.narrow().expand(), E2);
+
+    // .atIndex(1).atIndex(1) should be index 1.
+    ASSERT_EQ(PF2.atIndex(1).atIndex(1), PF2.atIndex(1));
+    ASSERT_EQ(PF2.atIndex(1).narrow().atIndex(1), PF2.atIndex(1));
+
+    // getArray() should give us the array field again.
+    ASSERT_EQ(E2.getArray(), PF2);
+
+    // One-after-the-end pointer.
+    const Pointer &O = PF2.atIndex(PF2.getNumElems());
+    ASSERT_TRUE(O.isLive());
+    ASSERT_TRUE(O.isOnePastEnd());
+    ASSERT_TRUE(O.isInitialized());
+    ASSERT_TRUE(O.getIndex() == PF2.getNumElems());
+  }
+
+  // Pointer to the third field (a composite array).
+  const Pointer &PF3 = GlobalPtr.atField(F3->Offset);
+  ASSERT_TRUE(PF3.isLive());
+  ASSERT_TRUE(PF3.isInitialized());
+  ASSERT_TRUE(PF3.isField());
+  ASSERT_TRUE(PF3.inArray());
+  ASSERT_TRUE(PF3.isArrayRoot());
+  ASSERT_FALSE(PF3.isArrayElement());
+  ASSERT_TRUE(PF3.getNumElems() == 3);
+  ASSERT_FALSE(PF3.isOnePastEnd());
+  ASSERT_FALSE(PF3.isRoot());
+  ASSERT_FALSE(PF3.getFieldDesc()->isPrimitive());
+  ASSERT_TRUE(PF3.getFieldDesc()->isArray());
+  ASSERT_TRUE(Pointer::hasSameBase(PF3, GlobalPtr));
+  ASSERT_TRUE(PF3.getBase() == GlobalPtr);
+  ASSERT_EQ(PF3.getRecord(), nullptr);
+  ASSERT_TRUE(PF3.getElemRecord());
+
+  // Check contents of field 3 (a composite array).
+  {
+    const Pointer &E1 = PF3.atIndex(0);
+    // Note that we didn't call narrow() above, so this points
+    // to an array element and not just a field.
+    ASSERT_TRUE(E1.isLive());
+    ASSERT_EQ(E1.getIndex(), 0);
+    ASSERT_TRUE(E1.isInitialized());
+    ASSERT_TRUE(E1.isArrayElement());
+    ASSERT_TRUE(E1.inArray());
+    ASSERT_FALSE(E1.isArrayRoot());
+    ASSERT_FALSE(E1.isRoot());
+    ASSERT_EQ(E1.getArray(), PF3);
+    ASSERT_TRUE(E1.isField());
+    ASSERT_TRUE(E1.getElemRecord());
+    ASSERT_FALSE(E1.getRecord());
+
+    // Now the same with narrow().
+    const Pointer &NE1 = PF3.atIndex(0).narrow();
+    ASSERT_NE(E1, NE1);
+    ASSERT_TRUE(NE1.isLive());
+    ASSERT_EQ(NE1.getIndex(), 0);
+    ASSERT_TRUE(NE1.isInitialized());
+    ASSERT_FALSE(NE1.isArrayElement());
+    ASSERT_TRUE(NE1.isField());
+    ASSERT_FALSE(NE1.inArray());
+    ASSERT_FALSE(NE1.isArrayRoot());
+    ASSERT_FALSE(NE1.isRoot());
+    // Not possible, since this is narrow()ed:
+    // ASSERT_EQ(NE1.getArray(), PF3);
+    ASSERT_EQ(NE1.expand(), E1);
+    ASSERT_FALSE(NE1.getElemRecord());
+    ASSERT_TRUE(NE1.getRecord());
+
+    // Second element, NOT narrowed.
+    const Pointer &E2 = PF3.atIndex(1);
+    ASSERT_TRUE(E2.isLive());
+    ASSERT_EQ(E2.getIndex(), 1);
+    ASSERT_TRUE(E2.isInitialized());
+    ASSERT_TRUE(E2.isArrayElement());
+    ASSERT_TRUE(E2.isField());
+    ASSERT_TRUE(E2.inArray());
+    ASSERT_FALSE(E2.isArrayRoot());
+    ASSERT_FALSE(E2.isRoot());
+    ASSERT_EQ(E2.getArray(), PF3);
+
+    // Second element, narrowed.
+    const Pointer &NE2 = PF3.atIndex(1).narrow();
+    ASSERT_TRUE(NE2.isLive());
+    ASSERT_EQ(NE2.getIndex(), 0);
+    ASSERT_TRUE(NE2.isInitialized());
+    ASSERT_FALSE(NE2.isArrayElement());
+    ASSERT_TRUE(NE2.isField());
+    ASSERT_FALSE(NE2.inArray());
+    ASSERT_FALSE(NE2.isArrayRoot());
+    ASSERT_FALSE(NE2.isRoot());
+    // Not possible, since this is narrow()ed:
+    // ASSERT_EQ(NE2.getArray(), PF3);
+    ASSERT_FALSE(NE2.getElemRecord());
+    ASSERT_TRUE(NE2.getRecord());
+
+    // Chained atIndex() without narrowing in between.
+    ASSERT_EQ(PF3.atIndex(1).atIndex(1), PF3.atIndex(1));
+
+    // First field of the second element.
+    const Pointer &FP1 = NE2.atField(NE2.getRecord()->getField(0u)->Offset);
+    ASSERT_TRUE(FP1.isLive());
+    ASSERT_TRUE(FP1.isInitialized());
+    ASSERT_EQ(FP1.getBase(), NE2);
+    ASSERT_FALSE(FP1.isArrayElement());
+    ASSERT_FALSE(FP1.inArray());
+    ASSERT_FALSE(FP1.inPrimitiveArray());
+    ASSERT_TRUE(FP1.isField());
+
+    // One-past-the-end of a composite array.
+    const Pointer &O = PF3.atIndex(PF3.getNumElems()).narrow();
+    ASSERT_TRUE(O.isOnePastEnd());
+    ASSERT_TRUE(O.isElementPastEnd());
+  }
+
+  // Pointer to the fourth field (a multidimensional primitive array).
+  const Pointer &PF4 = GlobalPtr.atField(F4->Offset);
+  ASSERT_TRUE(PF4.isLive());
+  ASSERT_TRUE(PF4.isInitialized());
+  ASSERT_TRUE(PF4.isField());
+  ASSERT_TRUE(PF4.inArray());
+  ASSERT_TRUE(PF4.isArrayRoot());
+  ASSERT_FALSE(PF4.isArrayElement());
+  ASSERT_TRUE(PF4.getNumElems() == 3);
+  ASSERT_FALSE(PF4.isOnePastEnd());
+  ASSERT_FALSE(PF4.isRoot());
+  ASSERT_FALSE(PF4.getFieldDesc()->isPrimitive());
+  ASSERT_TRUE(PF4.getFieldDesc()->isArray());
+  ASSERT_TRUE(Pointer::hasSameBase(PF4, GlobalPtr));
+  ASSERT_TRUE(PF4.getBase() == GlobalPtr);
+  ASSERT_EQ(PF4.getRecord(), nullptr);
+  ASSERT_EQ(PF4.getElemRecord(), nullptr);
+  ASSERT_NE(PF4.getField(), nullptr);
+  ASSERT_TRUE(PF4.getFieldDesc()->ElemDesc->isPrimitiveArray());
+  // Check contents of field 4 (a primitive array).
+  {
+    // Pointer to the first element, is of type short[3].
+    const Pointer &E1 = PF4.atIndex(0);
+    ASSERT_NE(E1, PF4);
+    ASSERT_TRUE(E1.isLive());
+    ASSERT_TRUE(E1.isArrayElement());
+    ASSERT_TRUE(E1.inArray());
+    ASSERT_EQ(E1.getNumElems(), 3u);
+    ASSERT_EQ(E1.getIndex(), 0u);
+    ASSERT_EQ(E1.getArray(), PF4);
+
+    // Now narrow()'ed.
+    const Pointer &NE1 = PF4.atIndex(0).narrow();
+    ASSERT_NE(NE1, PF4);
+    ASSERT_NE(NE1, E1);
+    ASSERT_TRUE(NE1.isLive());
+    ASSERT_FALSE(NE1.isArrayElement());
+    ASSERT_TRUE(NE1.isArrayRoot());
+    ASSERT_FALSE(NE1.getFieldDesc()->isCompositeArray());
+    ASSERT_TRUE(NE1.getFieldDesc()->isPrimitiveArray());
+    ASSERT_EQ(NE1.getFieldDesc()->getNumElems(), 3u);
+    ASSERT_TRUE(NE1.inArray());
+    ASSERT_EQ(NE1.getNumElems(), 3u);
+    ASSERT_EQ(NE1.getIndex(), 0u);
+
+    // Last element of the first dimension.
+    const Pointer &PE1 = PF4.atIndex(0).narrow().atIndex(2);
+    ASSERT_TRUE(PE1.isLive());
+    ASSERT_EQ(PE1.deref<short>(), 3);
+    ASSERT_EQ(PE1.getArray(), NE1);
+    ASSERT_EQ(PE1.getIndex(), 2u);
+
+    // third dimension
+    const Pointer &E3 = PF4.atIndex(2);
+    ASSERT_NE(E3, PF4);
+    ASSERT_TRUE(E3.isLive());
+    ASSERT_TRUE(E3.isArrayElement());
+    ASSERT_FALSE(E3.isArrayRoot());
+    ASSERT_TRUE(E3.inArray());
+    ASSERT_EQ(E3.getNumElems(), 3u);
+    ASSERT_EQ(E3.getIndex(), 2u);
+
+    // Same, but narrow()'ed.
+    const Pointer &NE3 = PF4.atIndex(2).narrow();
+    ASSERT_NE(NE3, PF4);
+    ASSERT_NE(NE3, E1);
+    ASSERT_TRUE(NE3.isLive());
+    ASSERT_FALSE(NE3.isArrayElement());
+    ASSERT_TRUE(NE3.isArrayRoot());
+    ASSERT_FALSE(NE3.getFieldDesc()->isCompositeArray());
+    ASSERT_TRUE(NE3.getFieldDesc()->isPrimitiveArray());
+    ASSERT_EQ(NE3.getFieldDesc()->getNumElems(), 3u);
+    ASSERT_TRUE(NE3.inArray());
+    ASSERT_EQ(NE3.getNumElems(), 3u);
+    // This is narrow()'ed, so not an "array elemnet"
+    ASSERT_EQ(PF4.atIndex(2).getIndex(), 2u);
+    ASSERT_EQ(NE3.getIndex(), 0u);
+
+    // Last element of the last dimension
+    const Pointer &PE3 = PF4.atIndex(2).narrow().atIndex(2);
+    ASSERT_TRUE(PE3.isLive());
+    ASSERT_EQ(PE3.deref<short>(), 9);
+    ASSERT_EQ(PE3.getArray(), NE3);
+    ASSERT_EQ(PE3.getIndex(), 2u);
+  }
+}