[clang][Interp] Handle ImplictValueInitExprs

[tbaeder]

Summary

I don't have a test case handy for them since I'm not sure how to trigger them reliably, but they are easy enough to implement and I ran into them while working on array fillers.

[erichkeane]

I assume we're going to see more patches in the future in this space as you discover examples/tests for this, but in order to unblock other tests, this is good enough for now.

[aaron.ballman]

I don't have a test case handy for them since I'm not sure how to trigger them reliably, but they are easy enough to implement and I ran into them while working on array fillers.

I think we should have test coverage for this if possible. https://godbolt.org/z/75jGrcT7v shows an example, but it might be that it's hard to test that example without other interpreter support first (in which case, you should add the example but comment out any bits that need it so that the test passes, along with a FIXME comment).

[aaron.ballman]

LGTM!

clang/test/AST/Interp/arrays.cpp

14

I wish we could find some solution that didn't require this so that the test case breaks when we do get around to implementing support for the other bits. But this is at least a good start!

[tbaeder]

clang/test/AST/Interp/arrays.cpp

14

Usually we could just keep it enabled and add the appropriate expected-error parts, but in this case we run into an assertion later on and that doesn't work.

clang/lib/AST/Interp/ByteCodeExprGen.h

public:
   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);
 
 protected:
   bool visitExpr(const Expr *E) override;
   bool visitDecl(const VarDecl *VD) override;
 
 protected:
   /// Emits scope cleanup instructions.
   void emitCleanup();

clang/lib/AST/Interp/ByteCodeExprGen.cpp

default:
       return this->bail(BO);
     }
   }
 
   return this->bail(BO);
 }
 
 template <class Emitter>
+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>::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);

clang/lib/AST/Interp/Opcodes.td

 def ConstUint32 : ConstOpcode<Uint32, ArgUint32>;
 def ConstSint64 : ConstOpcode<Sint64, ArgSint64>;
 def ConstUint64 : ConstOpcode<Uint64, ArgUint64>;
 def ConstBool : ConstOpcode<Bool, ArgBool>;
 
 // [] -> [Integer]
 def Zero : Opcode {
   let Types = [AluTypeClass];
+  let HasGroup = 1;
 }
 
 // [] -> [Pointer]
 def Null : Opcode {
   let Types = [PtrTypeClass];
 }
 
 //===----------------------------------------------------------------------===//

clang/test/AST/Interp/arrays.cpp

+// RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify %s
+// RUN: %clang_cc1 -verify=ref %s
+
+
+/// expected-no-diagnostics
+/// ref-no-diagnostics
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc99-extensions"
+#pragma clang diagnostic ignored "-Winitializer-overrides"
+/// 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