[clang][Interp] Implement record instance functions and returning struct types

[tbaeder]

Summary

Continuation of https://reviews.llvm.org/D134057. Implement passing a This pointer to instance functions as well as handling the RVO pointer. For the latter, I'm sure there are a lot of details left, but for now this works pretty well.

[tbaeder]

Ping

[aaron.ballman]

Generally looks reasonable to me.

clang/test/AST/Interp/records.cpp

47–50

Can you think of a reasonable way for us to test that you're handling the RVO pointer properly?

[tbaeder]

clang/test/AST/Interp/records.cpp

47–50

I think this is tested already by any function returning a non-primitive value, i.e. a struct or an array, e.g. getInts() above.

[aaron.ballman]

LGTM!

clang/test/AST/Interp/records.cpp

47–50

Oh derp, you're right!

clang/lib/AST/Interp/ByteCodeExprGen.cpp

for (const Expr *Init : InitList->inits()) {
         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->emitDupPtr(Init))
+          return false;
         if (!this->visit(Init))
           return false;
-        if (!this->emitInitElem(*T, ElementIndex, Init))
+        if (!this->emitInitElemPop(*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;
+  } else if (const auto *DIE = dyn_cast<CXXDefaultInitExpr>(Initializer)) {
+    return this->visitInitializer(DIE->getExpr());
   }
 
-  return true;
+  assert(false && "Unknown expression for array initialization");
+  return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visitRecordInitializer(const Expr *Initializer) {
   Initializer = Initializer->IgnoreParenImpCasts();
   assert(Initializer->getType()->isRecordType());
 
   if (const auto CtorExpr = dyn_cast<CXXConstructExpr>(Initializer)) {
if (const auto CtorExpr = dyn_cast<CXXConstructExpr>(Initializer)) {
     if (Func->hasRVO()) {
       // RVO functions expect a pointer to initialize on the stack.
       // Dup our existing pointer so it has its own copy to use.
       if (!this->emitDupPtr(Initializer))
         return false;
 
       return this->visit(CE);
     }
+  } else if (const auto *DIE = dyn_cast<CXXDefaultInitExpr>(Initializer)) {
+    return this->visitInitializer(DIE->getExpr());
   }
+
   return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visitInitializer(const Expr *Initializer) {
   QualType InitializerType = Initializer->getType();
 
   if (InitializerType->isArrayType())

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

bool ByteCodeStmtGen<Emitter>::visitFunc(const FunctionDecl *F) {
   // Constructor. Set up field initializers.
   if (const auto Ctor = dyn_cast<CXXConstructorDecl>(F)) {
     const RecordDecl *RD = Ctor->getParent();
     const Record *R = this->getRecord(RD);
 
     for (const auto *Init : Ctor->inits()) {
       const FieldDecl *Member = Init->getMember();
       const Expr *InitExpr = Init->getInit();
-
-      if (Optional<PrimType> T = this->classify(InitExpr->getType())) {
-        const Record::Field *F = R->getField(Member);
 
+      if (Optional<PrimType> T = this->classify(InitExpr->getType())) {
         if (!this->emitDupPtr(InitExpr))
           return false;
 
         if (!this->visit(InitExpr))
           return false;
 
         if (!this->emitInitField(*T, F->Offset, InitExpr))
           return false;
       } else {
-        assert(false && "Handle initializer for non-primitive values");
+        // Non-primitive case. Get a pointer to the field-to-initialize
+        // on the stack and call visitInitialzer() for it.
+        if (!this->emitDupPtr(InitExpr))
+          return false;
+
+        if (!this->emitGetPtrField(F->Offset, InitExpr))
+          return false;
+
+        if (!this->visitInitializer(InitExpr))
+          return false;
+
+        if (!this->emitPopPtr(InitExpr))
+          return false;
       }
     }
   }
 
   if (const auto *Body = F->getBody())
     if (!visitStmt(Body))
       return false;
 

clang/test/AST/Interp/records.cpp

 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify %s
 // RUN: %clang_cc1 -verify=ref %s
 
 // expected-no-diagnostics
 
 struct BoolPair {
   bool first;
   bool second;
 };
 
 struct Ints {
   int a = 20;
   int b = 30;
   bool c = true;
-  // BoolPair bp = {true, false}; FIXME
+  BoolPair bp = {true, false};
+  int numbers[3] = {1,2,3};
 
   static const int five = 5;
   static constexpr int getFive() {
     return five;
   }
 
   constexpr int getTen() const {
     return 10;
   }
 };
 
 static_assert(Ints::getFive() == 5, "");
 
 constexpr Ints ints;
 static_assert(ints.a == 20, "");
 static_assert(ints.b == 30, "");
 static_assert(ints.c, "");
 static_assert(ints.getTen() == 10, "");
 
+constexpr const BoolPair &BP = ints.bp;
+static_assert(BP.first, "");
+static_assert(!BP.second, "");
+static_assert(ints.bp.first, "");
+static_assert(!ints.bp.second, "");
+
+
 constexpr Ints ints2{-20, -30, false};
 static_assert(ints2.a == -20, "");
 static_assert(ints2.b == -30, "");
 static_assert(!ints2.c, "");
 
 constexpr Ints getInts() {
   return {64, 128, true};
 }
 constexpr Ints ints3 = getInts();
 static_assert(ints3.a == 64, "");
 static_assert(ints3.b == 128, "");
 static_assert(ints3.c, "");
 
 constexpr Ints ints4 = {
   .a = 40 * 50,
   .b = 0,