[clang][Interp] Fix passing parameters of composite type

[tbaeder]

Summary

We pass these as pointers, so we need to be careful not to emit pointers
to pointers when we emit visit DeclRefExprs pointing to parameters.

[shafik]

clang/lib/AST/Interp/ByteCodeEmitter.h

71

I don't understand the additional comment,

clang/lib/AST/Interp/Context.cpp

30

left over debugging code?

56

Left over debugging code?

[tbaeder]

clang/lib/AST/Interp/ByteCodeEmitter.h

71

It's supposed to be the types of the map, but I've removed the comment change locally.

clang/lib/AST/Interp/Context.cpp

30

Yes

56

Yes

[aaron.ballman]

LGTM with debugging code removed and comments cleaned up.

clang/lib/AST/Interp/ByteCodeEmitter.h

protected:
   bool jumpTrue(const LabelTy &Label);
   bool jumpFalse(const LabelTy &Label);
   bool jump(const LabelTy &Label);
   bool fallthrough(const LabelTy &Label);
 
   /// Callback for local registration.
   Local createLocal(Descriptor *D);
 
-  /// Parameter indices.
-  llvm::DenseMap<const ParmVarDecl *, unsigned> Params;
+  /// Parameter indices. <AstNode*, pair<Offset, IsPrimitive>>
+  llvm::DenseMap<const ParmVarDecl *, ParamOffset> Params;
   /// Lambda captures.
-  /// Map from Decl* to [Offset, IsReference] pair.
-  llvm::DenseMap<const ValueDecl *, std::pair<unsigned, bool>> LambdaCaptures;
+  llvm::DenseMap<const ValueDecl *, ParamOffset> LambdaCaptures;
   unsigned LambdaThisCapture;
   /// Local descriptors.
   llvm::SmallVector<SmallVector<Local, 8>, 2> Descriptors;
 
 private:
   /// Current compilation context.
   Context &Ctx;
   /// Program to link to.

clang/lib/AST/Interp/ByteCodeEmitter.cpp

if (isLambdaCallOperator(MD)) {
       // FIXME: LambdaThisCapture
       (void)LTC;
     }
   }
 
   // Assign descriptors to all parameters.
   // Composite objects are lowered to pointers.
   for (const ParmVarDecl *PD : FuncDecl->parameters()) {
-    PrimType Ty = Ctx.classify(PD->getType()).value_or(PT_Ptr);
-    Descriptor *Desc = P.createDescriptor(PD, Ty);
-    ParamDescriptors.insert({ParamOffset, {Ty, Desc}});
-    Params.insert({PD, ParamOffset});
+    std::optional<PrimType> T = Ctx.classify(PD->getType());
+    PrimType PT = T.value_or(PT_Ptr);
+    Descriptor *Desc = P.createDescriptor(PD, PT);
+    ParamDescriptors.insert({ParamOffset, {PT, Desc}});
+    Params.insert({PD, {ParamOffset, T != std::nullopt}});
     ParamOffsets.push_back(ParamOffset);
-    ParamOffset += align(primSize(Ty));
-    ParamTypes.push_back(Ty);
+    ParamOffset += align(primSize(PT));
+    ParamTypes.push_back(PT);
   }
 
   // Create a handle over the emitted code.
   Function *Func = P.getFunction(FuncDecl);
   if (!Func)
     Func = P.createFunction(FuncDecl, ParamOffset, std::move(ParamTypes),
                             std::move(ParamDescriptors),
                             std::move(ParamOffsets), HasThisPointer, HasRVO);

clang/lib/AST/Interp/ByteCodeExprGen.cpp

 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::dereferenceParam(
     const Expr *LV, PrimType T, const ParmVarDecl *PD, DerefKind AK,
     llvm::function_ref<bool(PrimType)> Direct,
     llvm::function_ref<bool(PrimType)> Indirect) {
   auto It = this->Params.find(PD);
   if (It != this->Params.end()) {
-    unsigned Idx = It->second;
+    unsigned Idx = It->second.Offset;
     switch (AK) {
     case DerefKind::Read:
       return DiscardResult ? true : this->emitGetParam(T, Idx, LV);
 
     case DerefKind::Write:
       if (!Direct(T))
         return false;
       if (!this->emitSetParam(T, Idx, LV))
if (auto It = Locals.find(D); It != Locals.end()) {
     return this->emitGetPtrLocal(Offset, E);
   } else if (auto GlobalIndex = P.getGlobal(D)) {
     if (IsReference)
       return this->emitGetGlobalPtr(*GlobalIndex, E);
 
     return this->emitGetPtrGlobal(*GlobalIndex, E);
   } else if (const auto *PVD = dyn_cast<ParmVarDecl>(D)) {
     if (auto It = this->Params.find(PVD); It != this->Params.end()) {
-      if (IsReference)
-        return this->emitGetParamPtr(It->second, E);
-      return this->emitGetPtrParam(It->second, E);
+      if (IsReference || !It->second.IsPtr)
+        return this->emitGetParamPtr(It->second.Offset, E);
+
+      return this->emitGetPtrParam(It->second.Offset, E);
     }
   }
 
   // Handle lambda captures.
   if (auto It = this->LambdaCaptures.find(D);
       It != this->LambdaCaptures.end()) {
-    auto [Offset, IsReference] = It->second;
+    auto [Offset, IsPtr] = It->second;
 
-    if (IsReference)
+    if (IsPtr)
       return this->emitGetThisFieldPtr(Offset, E);
     return this->emitGetPtrThisField(Offset, E);
   }
 
   return false;
 }
 
 template <class Emitter>

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

bool ByteCodeStmtGen<Emitter>::emitLambdaStaticInvokerBody(
   // Forward all arguments from the static invoker to the lambda call operator.
   for (const ParmVarDecl *PVD : MD->parameters()) {
     auto It = this->Params.find(PVD);
     assert(It != this->Params.end());
 
     // We do the lvalue-to-rvalue conversion manually here, so no need
     // to care about references.
     PrimType ParamType = this->classify(PVD->getType()).value_or(PT_Ptr);
-    if (!this->emitGetParam(ParamType, It->second, MD))
+    if (!this->emitGetParam(ParamType, It->second.Offset, MD))
       return false;
   }
 
   if (!this->emitCall(Func, LambdaCallOp))
     return false;
 
   this->emitCleanup();
   if (ReturnType)

clang/lib/AST/Interp/Context.h

 class VarDecl;
 
 namespace interp {
 class Function;
 class Program;
 class State;
 enum PrimType : unsigned;
 
+struct ParamOffset {
+  unsigned Offset;
+  bool IsPtr;
+};
+
 /// Holds all information required to evaluate constexpr code in a module.
 class Context final {
 public:
   /// Initialises the constexpr VM.
   Context(ASTContext &Ctx);
 
   /// Cleans up the constexpr VM.
   ~Context();

clang/lib/AST/Interp/Context.cpp

 using namespace clang;
 using namespace clang::interp;
 
 Context::Context(ASTContext &Ctx) : Ctx(Ctx), P(new Program(*this)) {}
 
 Context::~Context() {}
 
 bool Context::isPotentialConstantExpr(State &Parent, const FunctionDecl *FD) {
+  llvm::errs() << __PRETTY_FUNCTION__ << "\n";
+  FD->dump();
   assert(Stk.empty());
   Function *Func = P->getFunction(FD);
   if (!Func || !Func->hasBody()) {
     if (auto R = ByteCodeStmtGen<ByteCodeEmitter>(*this, *P).compileFunc(FD)) {
       Func = *R;
     } else {
       handleAllErrors(R.takeError(), [&Parent](ByteCodeGenError &Err) {
         Parent.FFDiag(Err.getRange().getBegin(),
                       diag::err_experimental_clang_interp_failed)
             << Err.getRange();
       });
       return false;
     }
   }
 
   APValue DummyResult;
   if (!Run(Parent, Func, DummyResult)) {
     return false;
   }
 
   return Func->isConstexpr();
 }
 
 bool Context::evaluateAsRValue(State &Parent, const Expr *E, APValue &Result) {
+  llvm::errs() << __PRETTY_FUNCTION__ << "\n";
+  E->dump();
+
   assert(Stk.empty());
   ByteCodeExprGen<EvalEmitter> C(*this, *P, Parent, Stk, Result);
   if (Check(Parent, C.interpretExpr(E))) {
     assert(Stk.empty());
     return true;
   }
 
   Stk.clear();

clang/lib/AST/Interp/EvalEmitter.h

protected:
   Local createLocal(Descriptor *D);
 
   /// Returns the source location of the current opcode.
   SourceInfo getSource(const Function *F, CodePtr PC) const override {
     return (F && F->hasBody()) ? F->getSource(PC) : CurrentSource;
   }
 
   /// Parameter indices.
-  llvm::DenseMap<const ParmVarDecl *, unsigned> Params;
+  llvm::DenseMap<const ParmVarDecl *, ParamOffset> Params;
   /// Lambda captures.
-  /// Map from Decl* to [Offset, IsReference] pair.
-  llvm::DenseMap<const ValueDecl *, std::pair<unsigned, bool>> LambdaCaptures;
+  llvm::DenseMap<const ValueDecl *, ParamOffset> LambdaCaptures;
   unsigned LambdaThisCapture;
   /// Local descriptors.
   llvm::SmallVector<SmallVector<Local, 8>, 2> Descriptors;
 
 private:
   /// Current compilation context.
   Context &Ctx;
   /// Current program.

clang/test/AST/Interp/lambda.cpp

namespace LambdaParams {
   constexpr int foo() {
     int a = 0;
     auto f = [&a]() { ++a; };
 
     callThis(f);
 
     return a;
   }
-  /// FIXME: This should work in the new interpreter.
-#if 0
-  static_assert(foo() == 1); // expected-error {{not an integral constant expression}}
-#endif
+  static_assert(foo() == 1);
 }
 
 namespace LambdasAsParams {
   template<typename F>
   constexpr auto call(F f) {
     return f();
   }
   static_assert(call([](){ return 1;}) == 1);

clang/test/AST/Interp/records.cpp

namespace TemporaryObjectExpr {
   /// FIXME: This should also work in C++14, but it needs suport for
   ///   CXXConstructExpr. I think.
 #if __cplusplus > 201402L
   static_assert(foo(F()) == 0, "");
 #endif
 
 }
 
-#if 0
 constexpr bool BPand(BoolPair bp) {
   return bp.first && bp.second;
 }
 static_assert(BPand(BoolPair{true, false}) == false, "");
-#endif