[clang][Interp] Handle LambdaExprs

[tbaeder]

Summary

Unfortunately I couldn't find an existing test file in test/SemaCXX that focused on lambdas in constant expressions.

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[aaron.ballman]

clang/lib/AST/Interp/ByteCodeEmitter.cpp

56–57

UB alert -- _L is reserved; let's pick names without leading underscores or shadowing.

clang/lib/AST/Interp/ByteCodeEmitter.h

73–74

Can you add comments explaining what the unsigned, bool pair is encoding?

75

Why is this a pointer? Since it's not really implemented, I'd recommend removing this for now and adding it back when you add support for capturing this.

clang/test/AST/Interp/lambda.cpp

93

How about some tests like:

constexpr int call_thru_func_ptr(int i) {
  auto l = [](int i) { return i; };
  int (*fp)(int) = l;
  return fp(i);  
}
static_assert(call_thru_func_ptr(12) == 12);

constexpr int call_through_copied_lambda(auto lam, int i) {
  auto copy = lam;
  return copy(i);
}

constexpr int call_through_copied_lambda(auto lam) {
  auto copy = lam;
  return copy();
}

void func() {
  constexpr int i = 12;
  static_assert(call_through_copied_lambda([i]() { return i; }) == 12);
}

[tbaeder]

clang/test/AST/Interp/lambda.cpp

93

Heh:

array.cpp:1245:15: error: static assertion expression is not an integral constant expression
 1245 | static_assert(call_thru_func_ptr(12) == 12);
      |               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
array.cpp:1243:10: note: non-constexpr function '__invoke' cannot be used in a constant expression
 1243 |   return fp(i);
      |          ^
array.cpp:1245:15: note: in call to 'call_thru_func_ptr(12)'
 1245 | static_assert(call_thru_func_ptr(12) == 12);
      |               ^
array.cpp:1239:12: note: declared here
 1239 |   auto l = [](int i) { return i; };
      |            ^

[tbaeder]

clang/test/AST/Interp/lambda.cpp

93

Ah, I didn't know there is something like a "lambda static invoker". I see the current interpreter basically checks for that and then calls the lambda call operator instead. Doing that is hard for me though, because the call operator requires different arguments and I can't just itnogre the static invoker either because it has an empty body.

[tbaeder]

clang/test/AST/Interp/lambda.cpp

93

Okay, I think I figured it out, I'm just special-casing the static invoker and emitting byte code for its body manually. This will make the patch larger though.

[aaron.ballman]

clang/test/AST/Interp/lambda.cpp

93

Hmmm, aren't you going to need to emit a body for the static invoker for calling through a function pointer to it (the call_thru_func_ptr example)? I would imagine you'd need to emit both the static invoker and the call operator and have the static invoker call the call operator.

[shafik]

clang/test/AST/Interp/lambda.cpp

6

Fun case

int constexpr f() {
    return [x = 10] {
       decltype(x) y; // type int b/c not odr use
                      // refers to original init-capture
       auto &z = x; // type const int & b/c odr use
                     // refers to lambdas copy of x
        y = 10; // Ok
        //z = 10; // Ill-formed
        return y;
    }();
}

constexpr int x = f();

[aaron.ballman]

LGTM

clang/lib/AST/Interp/ByteCodeExprGen.cpp

900

clang/lib/AST/Interp/ByteCodeEmitter.h

protected:
   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;
+  /// Lambda captures.
+  /// Map from Decl* to [Offset, IsReference] pair.
+  llvm::DenseMap<const ValueDecl *, std::pair<unsigned, bool>> LambdaCaptures;
+  unsigned LambdaThisCapture;
   /// Local descriptors.
   llvm::SmallVector<SmallVector<Local, 8>, 2> Descriptors;
 
 private:
   /// Current compilation context.
   Context &Ctx;
   /// Program to link to.
   Program &P;

clang/lib/AST/Interp/ByteCodeEmitter.cpp

 //===--- ByteCodeEmitter.cpp - Instruction emitter for the VM ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ByteCodeEmitter.h"
 #include "Context.h"
 #include "Floating.h"
 #include "Opcode.h"
 #include "Program.h"
+#include "clang/AST/ASTLambda.h"
 #include "clang/AST/DeclCXX.h"
 #include <type_traits>
 
 using namespace clang;
 using namespace clang::interp;
 
 using APSInt = llvm::APSInt;
 using Error = llvm::Error;
if (!Ty->isVoidType() && !Ctx.classify(Ty)) {
     ParamTypes.push_back(PT_Ptr);
     ParamOffset += align(primSize(PT_Ptr));
   }
 
   // If the function decl is a member decl, the next parameter is
   // the 'this' pointer. This parameter is pop()ed from the
   // InterpStack when calling the function.
   bool HasThisPointer = false;
-  if (const auto *MD = dyn_cast<CXXMethodDecl>(FuncDecl);
-      MD && MD->isInstance()) {
+  if (const auto *MD = dyn_cast<CXXMethodDecl>(FuncDecl)) {
+    if (MD->isInstance()) {
       HasThisPointer = true;
       ParamTypes.push_back(PT_Ptr);
       ParamOffset += align(primSize(PT_Ptr));
     }
 
+    // Set up lambda capture to closure record field mapping.
+    if (isLambdaCallOperator(MD)) {
+      const Record *R = P.getOrCreateRecord(MD->getParent());
+      llvm::DenseMap<const ValueDecl *, FieldDecl *> LC;
+      FieldDecl *LTC;
+
+      MD->getParent()->getCaptureFields(LC, LTC);
+
+      for (auto Cap : LC) {
+        unsigned Offset = R->getField(Cap.second)->Offset;
+        this->LambdaCaptures[Cap.first] = {
+            Offset, Cap.second->getType()->isReferenceType()};
+      }
+      // 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});
     ParamOffset += align(primSize(Ty));

clang/lib/AST/Interp/ByteCodeExprGen.h

public:
   bool VisitCharacterLiteral(const CharacterLiteral *E);
   bool VisitCompoundAssignOperator(const CompoundAssignOperator *E);
   bool VisitFloatCompoundAssignOperator(const CompoundAssignOperator *E);
   bool VisitPointerCompoundAssignOperator(const CompoundAssignOperator *E);
   bool VisitExprWithCleanups(const ExprWithCleanups *E);
   bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
   bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
   bool VisitTypeTraitExpr(const TypeTraitExpr *E);
+  bool VisitLambdaExpr(const LambdaExpr *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

bool ByteCodeExprGen<Emitter>::VisitCompoundLiteralExpr(
   return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitTypeTraitExpr(const TypeTraitExpr *E) {
   return this->emitConstBool(E->getValue(), E);
 }
 
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitLambdaExpr(const LambdaExpr *E) {
+  // XXX We assume here that a pointer-to-initialize is on the stack.
+
+  const Record *R = P.getOrCreateRecord(E->getLambdaClass());
+
+  auto *CaptureInitIt = E->capture_init_begin();
+  // Initialize all fields (which represent lambda captures) of the
+  // record with their initializers.
+  for (const Record::Field &F : R->fields()) {
+    const Expr *Init = *CaptureInitIt;
+    ++CaptureInitIt;
+
+    if (std::optional<PrimType> T = classify(Init)) {
+      if (!this->visit(Init))
+        return false;
+
+      if (!this->emitSetField(*T, F.Offset, E))
+        return false;
+    } else {
+      if (!this->emitDupPtr(E))
+        return false;
+
+      if (!this->emitGetPtrField(F.Offset, E))
+        return false;
+
+      if (!this->visitInitializer(Init))
+        return false;
+
+      if (!this->emitPopPtr(E))
+        return false;
+    }
+  }
+
+  return true;
+}
+
 template <class Emitter> bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
   if (E->containsErrors())
     return false;
 
   OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/true);
   return this->Visit(E);
 }
 
bool ByteCodeExprGen<Emitter>::visitRecordInitializer(const Expr *Initializer) {
   } else if (const auto *CE = dyn_cast<CastExpr>(Initializer)) {
     return this->visitInitializer(CE->getSubExpr());
   } else if (const auto *CE = dyn_cast<CXXBindTemporaryExpr>(Initializer)) {
     return this->visitInitializer(CE->getSubExpr());
   } else if (const auto *ACO =
                  dyn_cast<AbstractConditionalOperator>(Initializer)) {
     return this->visitConditional(
         ACO, [this](const Expr *E) { return this->visitRecordInitializer(E); });
+  } else if (const auto *LE = dyn_cast<LambdaExpr>(Initializer)) {
+    return this->VisitLambdaExpr(LE);
   }
 
   return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visitInitializer(const Expr *Initializer) {
   QualType InitializerType = Initializer->getType();
bool ByteCodeExprGen<Emitter>::VisitDeclRefExpr(const DeclRefExpr *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);
     }
   }
 
+  // Handle lambda captures.
+  if (auto It = this->LambdaCaptures.find(D);
+      It != this->LambdaCaptures.end()) {
+    auto [Offset, IsReference] = It->second;
+
+    if (IsReference)
+      return this->emitGetThisFieldPtr(Offset, E);
+    return this->emitGetPtrThisField(Offset, E);
+  }
+
   return false;
 }
 
 template <class Emitter>
 void ByteCodeExprGen<Emitter>::emitCleanup() {
   for (VariableScope<Emitter> *C = VarScope; C; C = C->getParent())
     C->emitDestruction();
 }

clang/lib/AST/Interp/EvalEmitter.h

protected:
 
   /// 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;
+  /// Lambda captures.
+  /// Map from Decl* to [Offset, IsReference] pair.
+  llvm::DenseMap<const ValueDecl *, std::pair<unsigned, bool>> LambdaCaptures;
+  unsigned LambdaThisCapture;
   /// Local descriptors.
   llvm::SmallVector<SmallVector<Local, 8>, 2> Descriptors;
 
 private:
   /// Current compilation context.
   Context &Ctx;
   /// Current program.
   Program &P;

clang/lib/AST/Interp/Interp.h

bool SetField(InterpState &S, CodePtr OpPC, uint32_t I) {
   const Pointer &Obj = S.Stk.peek<Pointer>();
   if (!CheckNull(S, OpPC, Obj, CSK_Field))
     return false;
   if (!CheckRange(S, OpPC, Obj, CSK_Field))
     return false;
   const Pointer &Field = Obj.atField(I);
   if (!CheckStore(S, OpPC, Field))
     return false;
+  Field.initialize();
   Field.deref<T>() = Value;
   return true;
 }
 
 /// 1) Pops a pointer from the stack
 /// 2) Pushes the value of the pointer's field on the stack
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool GetFieldPop(InterpState &S, CodePtr OpPC, uint32_t I) {

clang/test/AST/Interp/lambda.cpp

+// RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify -std=c++20 %s
+// RUN: %clang_cc1 -verify=ref -std=c++20 %s
+
+constexpr int a = 12;
+constexpr int f = [c = a]() { return c; }();
+static_assert(f == a);
+
+
+constexpr int inc() {
+  int a = 10;
+  auto f = [&a]() {
+    ++a;
+  };
+
+  f();f();
+
+  return a;
+}
+static_assert(inc() == 12);
+
+constexpr int add(int a, int b) {
+  auto doIt = [a, b](int c) {
+    return a + b + c;
+  };
+
+  return doIt(2);
+}
+static_assert(add(4, 5) == 11);
+
+
+constexpr int add2(int a, int b) {
+  auto doIt = [a, b](int c) {
+    auto bar = [a]() { return a; };
+    auto bar2 = [b]() { return b; };
+
+    return bar() + bar2() + c;
+  };
+
+  return doIt(2);
+}
+static_assert(add2(4, 5) == 11);
+
+
+constexpr int div(int a, int b) {
+  auto f = [=]() {
+    return a / b; // expected-note {{division by zero}} \
+                  // ref-note {{division by zero}}
+  };
+
+  return f(); // expected-note {{in call to '&f->operator()()'}} \
+              // ref-note {{in call to '&f->operator()()'}}
+}
+static_assert(div(8, 2) == 4);
+static_assert(div(8, 0) == 4); // expected-error {{not an integral constant expression}} \
+                               // expected-note {{in call to 'div(8, 0)'}} \
+                               // ref-error {{not an integral constant expression}} \
+                               // ref-note {{in call to 'div(8, 0)'}}
+
+
+struct F {
+  float f;
+};
+
+constexpr float captureStruct() {
+  F someF = {1.0};
+
+  auto p = [someF]() {
+    return someF.f;
+  };
+
+  return p();
+}
+
+static_assert(captureStruct() == 1.0);
+
+
+int constexpr FunCase() {
+    return [x = 10] {
+       decltype(x) y; // type int b/c not odr use
+                      // refers to original init-capture
+       auto &z = x; // type const int & b/c odr use
+                     // refers to lambdas copy of x
+        y = 10; // Ok
+        //z = 10; // Ill-formed
+        return y;
+    }();
+}
+
+constexpr int WC = FunCase();
+
+
+namespace LambdaParams {
+  template<typename T>
+  constexpr void callThis(T t) {
+    return t();
+  }
+
+  constexpr int foo() {
+    int a = 0;
+    auto f = [&a]() { ++a; };
+
+    callThis(f);
+
+    return a;
+  }
+  /// FIXME: This should work in the new interpreter.
+  static_assert(foo() == 1); // expected-error {{not an integral constant expression}}
+}
+