[LLDB][ClangExpression] Allow expression evaluation from within C++ Lambdas

[Michael137]

Summary

This patch adds support for evaluating expressions which reference
a captured this from within the context of a C++ lambda expression.
Currently LLDB doesn't provide Clang with enough information to
determine that we're inside a lambda expression and are allowed to
access variables on a captured this; instead Clang simply fails
to parse the expression.

There are two problems to solve here:

1. Make sure clang::Sema doesn't reject the expression due to illegal member access.
2. Materialize all the necessary captured variables/member variables required to evaluate the expression.

To address (1), we currently import the outer structure's AST context
onto $__lldb_class, making the contextClass and the NamingClass
match, a requirement by clang::Sema::BuildPossibleImplicitMemberExpr.

To address (2), we inject all captured variables as locals into the
expression source code.

Testing

• Added API test

[Michael137]

The is a draft for now, but feel free to comment on the approach. I'm still evaluating some other alternatives to this.

[Michael137]

This comment was removed by Michael137.

[Michael137]

Correct email config

[Michael137]

Remove from review queue for now

[Michael137]

• [LLDB][NFC] Create variable for hardcoded alignment/size constants in materializer
• [LLDB][Expression] Allow instantiation of IR Entity from ValueObject
• Removed redundant m_object_pointer_type

[Michael137]

• Add AddOneVariable overload that takes ValueObjectSP

[Michael137]

• Fixed doc

[jingham]

I'm not sure whether I'm bothered that this patch handles the other captures for lambda's with captured "this" pretty differently from ones that don't capture "this". But the method for the ones that don't capture "this" is more straightforward, so maybe that's desirable.

You introduced a handful of API's that take StackFrame *'s but then their callers end up having StackFrameSP's that they have to call "get" on to pass to your new API's. That doesn't seem desirable.

Other inline comments...

lldb/source/Expression/Materializer.cpp

31

This seems weird to me. You didn't do it, you're just replacing hard-coded 8's later in the code. But this seems like something we should be getting from the target? You don't need to solve this for this patch since it isn't intrinsic to it, but at least leave a FIXME...

808

Naively it seems like it would be a bad idea to call GetValueObject twice. We don't want independent ValueObjectVariable shared pointers floating around for the same Entity. Should this maybe do an if (!m_variable_sp) first?

850

Is this right? For instance, in the case where the fake "this" Variable in the lambda expression has an invalid expression, all the ValueObjects you try to make (the "real captured this" as well as any other captures that were hanging off the fake "this" would have invalid location expressions.

lldb/source/Expression/UserExpression.cpp

101–102

Can we think of a better name for this? Having two instances of Object with different meanings in the same name is confusing? Even GetObjectPointerValueObject would be clearer.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

70

This comment is confusing. Partly because you refer to an "unnamed structure" which you then look up by name "this". I think it's clearer to say that clang makes an artificial class whose members are the captures, and makes the lambda look like a method of that class. Then the captured "this" is a special case of all the captures.

This method also ONLY returns the fake this if the real "this" was captured, which you should say.

1690

Is there enough advantage to move-ing the incoming valobj as opposed to just copying the shared pointer? It's a little weird to have API's that consume one of their incoming arguments. If that really is worth doing, you should note that you've done that.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp

229

It's worth noting that you handle lambda's that capture "this" and lambda's that don't capture "this" differently. In the former case, we promote all the captures to local variables and ignore the fake this. In the latter case (because GetLambdaValueObject only returns a valid ValueObjectSP if it has a child called "this"), we keep finding the values by implicit lookup in the fake this instead.

I don't think that a problem, no need to use the more complex method just for consistency, but you should note that somewhere.

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

202

Why did you make this take a StackFrame *? It seems to force some other functions to change from StackFrameSP to StackFrame * but the only place it gets called it has a StackFrameSP, and explicitly calls get to make it a pointer. That seems awkward.

[Michael137]

lldb/source/Expression/Materializer.cpp

808

m_variable_sp is used here to create a new ValueObjectVariable. It's a precondition that m_variable_sp != nullptr (will add that to the function documentation). I could add a m_value_object_var member that we set if it hasn't been set before.

850

If the location expression is invalid for the fake "this", would we ever be able to get ValueObject's out of it? By the time these Entity objects get instantiated we either managed to get ValueObject's from "this" or if we didn't, then we wouldn't have added them to the $__lldb_local_vars namespace

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

1690

Not particularly, don't imagine there's a measurable difference. A copy isn't necessary so I was trying to avoid it. I guess a clearer way would be to just not pass the shared_ptr around, and instead a ValueObject const&

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp

229

Good point, will add a comment

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

202

Was simply trying to avoid a shared_ptr copy where it wasn't necessary. Arguably the GetObjectPointer API should just take a StackFrame const&

[Michael137]

• Add more documentation
• Moved GetLambdaValueObject into common utility header
• Added defensive check to EntityVariable::GetValueObject

[Michael137]

• Move helper into new namespace

[aprantl]

Nice work! I only had superficial comments, maybe let's also wait for @jingham to accept the patch.

lldb/include/lldb/Expression/UserExpression.h

283

Nit: The LLVM style wants doxygen comments in the .h file, would be nice to add one here.

lldb/source/Expression/Materializer.cpp

31

Yeah this is odd, maybe we can clean this up in a follow-up commit.

436

FWIW, the refactoring of EntityVariable could have been a separate preparatory NFC patch, then the patch that adds the lambda functionality would be shorter. It's fine either way, but it's usually easier to review two simple comments instead of one complex one :-)

798

Maybe add a doxygen comment explaining when this subclass is used as opposed to EntityValueObject?

834

Micro-nit: . at the end of sentence.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

835

Nice!

1105

Maybe comment that this is the lambda/this-capture path?

1669

Nit:

LLVM style would be

ClangExpressionVariable::ParserVars *parser_vars =
          AddExpressionVariable(context, pt, ut, valobj);
if (!parser_vars)
  return;

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h

593

Doxygen comment (unless this is is an override function (but it's not marked as such))?

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp

222

at some point we should add a children() method that returns a range...

306

not your code, but this one has an iterator :-)

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionUtil.cpp

2

the -*- C++ -*- marker only makes sense for .h files, where it's ambiguous whether it's a C or a C++ header.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h

132

Here a /// comment on top of the declaration might be more readable. (Maybe fix this for the entire class in a follow-up commit)

[Michael137]

• Address stylistic/documentation comments

lldb/source/Expression/Materializer.cpp

436

True
I added it as a separate commit to this revision. Wasn't sure whether a separate patch was preferred over a separate commit in the same Phabricator revision.

[Michael137]

• LocationExpressionIsValid returns false for invalid ValueObjects
• Add asserts to EntityValueObject overrides
• Add docs for AddValueObject

[Michael137]

lldb/source/Expression/Materializer.cpp

850

Added a check for ValueObject's error status here.

Manual testing shows we'd catch lack of variable location earlier in materialisation

[jingham]

One trivial naming tweak, otherwise this looks good.

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionUtil.cpp

21

lldb generally uses "this_val_sp" form for local variables. Camel case is for method names, initial lower camel case for llvm method names.

[Michael137]

• Address stylistic comments

[Michael137]

After playing around with this some more I found an edge case with conditional breakpoints (in fact any place where we reuse an LLVMUserExpression). Modifying lldb/test/API/functionalities/breakpoint/two_hits_one_actual such that the helper method is inside a lambda like so:

struct Foo {
  void usleep_helper(int usec) {
    [this, &usec] {
        // Break here in the helper
        std::this_thread::sleep_for(std::chrono::duration<unsigned int, std::milli>(usec));
    }();
  }
};

void *background_thread(void *arg) {
    (void) arg;
    Foo f;
    for (;;) {
        f.usleep_helper(2);
    }
}

int main(void) {
  std::thread main_thread(background_thread, nullptr);
  Foo f;
  for (;;) {
    f.usleep_helper(1);
  }
}

Then setting a breakpoint twice, one for usec == 1 and usec == 100, we would end up hitting the breakpoint even if usec == 2 because conditional breakpoints re-use Materializer (and thus Entity objects). Since EntityValueObject::GetValueObject simply returns the ValueObject it was instantiated with, the usec == 1 condition always evaluates to true. Have a fix for this but verifying whether that really is the best approach.

[Michael137]

• Add test for conditional breakpoints on lambda captures

[Michael137]

• Add ValueObjectProvider so materializer doesn't use incorrect ValueObject when re-using UserExpressions

[Michael137]

• Remove now redundant m_lldb_value_object

[Michael137]

• Fix assertion

[Michael137]

• Remove redundant moves

[jingham]

This looks good to me. I had a trivial comment about comments. You added a test for the condition in lambda as well, that's great!

lldb/include/lldb/Expression/Materializer.h

88

We seem to put empty /// lines between each of the parameters in most other places. I think that makes them marginally easier to read, and it's what we do in most other places...

[Michael137]

• Doxgyen format improvements

[Michael137]

Missed the differential link in the commits.

This patch has been merged to main in following commits:

8184b252cdab2fbe44f766d6de28b29ebe4c8753
fcf4e252f4d992cade4bdfe5aed10ff96fa40202
317c8bf84d185c6b4a51a415c0deb7f8af661cb6

lldb/include/lldb/Expression/Materializer.h

public:
     virtual ConstString GetName() = 0;
     virtual void DidDematerialize(lldb::ExpressionVariableSP &variable) = 0;
   };
 
   uint32_t
   AddPersistentVariable(lldb::ExpressionVariableSP &persistent_variable_sp,
                         PersistentVariableDelegate *delegate, Status &err);
   uint32_t AddVariable(lldb::VariableSP &variable_sp, Status &err);
+
+  /// Create entity from supplied ValueObject and count it as a member
+  /// of the materialized struct.
+  ///
+  /// Behaviour is undefined if 'valobj_provider' is empty.
+  ///
+  /// \param[in] name Name of variable to materialize
+  ///
+  /// \param[in] valobj_provider When materializing values multiple
+  ///            times, this callback gets used to fetch a fresh
+  ///            ValueObject corresponding to the supplied frame.
+  ///            This is mainly used for conditional breakpoints
+  ///            that re-apply an expression whatever the frame
+  ///            happens to be when the breakpoint got hit.
+  ///
+  /// \param[out] err Error status that gets set on error.
+  ///
+  /// \returns Offset in bytes of the member we just added to the
+  ///          materialized struct.
+  uint32_t AddValueObject(ConstString name,
+                          ValueObjectProviderTy valobj_provider, Status &err);
+
   uint32_t AddResultVariable(const CompilerType &type, bool is_lvalue,
                              bool keep_in_memory,
                              PersistentVariableDelegate *delegate, Status &err);
   uint32_t AddSymbol(const Symbol &symbol_sp, Status &err);
   uint32_t AddRegister(const RegisterInfo &register_info, Status &err);
 
   uint32_t GetStructAlignment() { return m_struct_alignment; }
 

lldb/include/lldb/Expression/UserExpression.h

protected:
   DoExecute(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
             const EvaluateExpressionOptions &options,
             lldb::UserExpressionSP &shared_ptr_to_me,
             lldb::ExpressionVariableSP &result) = 0;
 
   static lldb::addr_t GetObjectPointer(lldb::StackFrameSP frame_sp,
                                        ConstString &object_name, Status &err);
 
+  /// Return ValueObject for a given variable name in the current stack frame
+  ///
+  /// \param[in] frame Current stack frame. When passed a 'nullptr', this
+  ///                  function returns an empty ValueObjectSP.
+  ///
+  /// \param[in] object_name Name of the variable in the current stack frame
+  ///                        for which we want the ValueObjectSP.
+  ///
+  /// \param[out] err Status object which will get set on error.
+  ///
+  /// \returns On success returns a ValueObjectSP corresponding to the variable
+  ///          with 'object_name' in the current 'frame'. Otherwise, returns
+  ///          'nullptr' (and sets the error status parameter 'err').
+  static lldb::ValueObjectSP
+  GetObjectPointerValueObject(lldb::StackFrameSP frame,
+                              ConstString const &object_name, Status &err);
+
   /// Populate m_in_cplusplus_method and m_in_objectivec_method based on the
   /// environment.
 
   void InstallContext(ExecutionContext &exe_ctx);
 
   bool LockAndCheckContext(ExecutionContext &exe_ctx, lldb::TargetSP &target_sp,
                            lldb::ProcessSP &process_sp,
                            lldb::StackFrameSP &frame_sp);

lldb/include/lldb/lldb-private-types.h

virtual bool IsValid(Platform &platform,
                        const ExecutionContext &target) const = 0;
   virtual const char *ShortConditionString() const = 0;
   virtual const char *LongConditionString() const = 0;
 };
 
 typedef struct type128 { uint64_t x[2]; } type128;
 typedef struct type256 { uint64_t x[4]; } type256;
 
+/// Functor that returns a ValueObjectSP for a variable given its name
+/// and the StackFrame of interest. Used primarily in the Materializer
+/// to refetch a ValueObject when the ExecutionContextScope changes.
+using ValueObjectProviderTy =
+    std::function<lldb::ValueObjectSP(ConstString, StackFrame *)>;
+
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 
 #endif // LLDB_LLDB_PRIVATE_TYPES_H

lldb/source/Expression/Materializer.cpp

 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
+#include "lldb/lldb-forward.h"
 
 #include <memory>
 
 using namespace lldb_private;
 
+// FIXME: these should be retrieved from the target
+//        instead of being hard-coded. Currently we
+//        assume that persistent vars are materialized
+//        as references, and thus pick the size of a
+//        64-bit pointer.
+static constexpr uint32_t g_default_var_alignment = 8;
+static constexpr uint32_t g_default_var_byte_size = 8;
+
 uint32_t Materializer::AddStructMember(Entity &entity) {
   uint32_t size = entity.GetSize();
   uint32_t alignment = entity.GetAlignment();
 
   uint32_t ret;
 
   if (m_current_offset == 0)
     m_struct_alignment = alignment;

 class EntityPersistentVariable : public Materializer::Entity {
 public:
   EntityPersistentVariable(lldb::ExpressionVariableSP &persistent_variable_sp,
                            Materializer::PersistentVariableDelegate *delegate)
       : Entity(), m_persistent_variable_sp(persistent_variable_sp),
         m_delegate(delegate) {
     // Hard-coding to maximum size of a pointer since persistent variables are
     // materialized by reference
-    m_size = 8;
-    m_alignment = 8;
+    m_size = g_default_var_byte_size;
+    m_alignment = g_default_var_alignment;
   }
 
   void MakeAllocation(IRMemoryMap &map, Status &err) {
     Log *log = GetLog(LLDBLog::Expressions);
 
     // Allocate a spare memory area to store the persistent variable's
     // contents.
 
uint32_t Materializer::AddPersistentVariable(
   EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
   *iter = std::make_unique<EntityPersistentVariable>(persistent_variable_sp,
                                                      delegate);
   uint32_t ret = AddStructMember(**iter);
   (*iter)->SetOffset(ret);
   return ret;
 }
 
-class EntityVariable : public Materializer::Entity {
+/// Base class for materialization of Variables and ValueObjects.
+///
+/// Subclasses specify how to obtain the Value which is to be
+/// materialized.
+class EntityVariableBase : public Materializer::Entity {
 public:
-  EntityVariable(lldb::VariableSP &variable_sp)
-      : Entity(), m_variable_sp(variable_sp) {
+  virtual ~EntityVariableBase() = default;
+
+  EntityVariableBase() {
     // Hard-coding to maximum size of a pointer since all variables are
     // materialized by reference
-    m_size = 8;
-    m_alignment = 8;
-    m_is_reference =
-        m_variable_sp->GetType()->GetForwardCompilerType().IsReferenceType();
+    m_size = g_default_var_byte_size;
+    m_alignment = g_default_var_alignment;
   }
 
   void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                    lldb::addr_t process_address, Status &err) override {
     Log *log = GetLog(LLDBLog::Expressions);
 
     const lldb::addr_t load_addr = process_address + m_offset;
     if (log) {
       LLDB_LOGF(log,
                 "EntityVariable::Materialize [address = 0x%" PRIx64
                 ", m_variable_sp = %s]",
-                (uint64_t)load_addr, m_variable_sp->GetName().AsCString());
+                (uint64_t)load_addr, GetName().GetCString());
     }
 
     ExecutionContextScope *scope = frame_sp.get();
 
     if (!scope)
       scope = map.GetBestExecutionContextScope();
 
-    lldb::ValueObjectSP valobj_sp =
-        ValueObjectVariable::Create(scope, m_variable_sp);
+    lldb::ValueObjectSP valobj_sp = SetupValueObject(scope);
 
     if (!valobj_sp) {
       err.SetErrorStringWithFormat(
-          "couldn't get a value object for variable %s",
-          m_variable_sp->GetName().AsCString());
+          "couldn't get a value object for variable %s", GetName().AsCString());
       return;
     }
 
     Status valobj_error = valobj_sp->GetError();
 
     if (valobj_error.Fail()) {
       err.SetErrorStringWithFormat("couldn't get the value of variable %s: %s",
-                                   m_variable_sp->GetName().AsCString(),
+                                   GetName().AsCString(),
                                    valobj_error.AsCString());
       return;
     }
 
     if (m_is_reference) {
       DataExtractor valobj_extractor;
       Status extract_error;
       valobj_sp->GetData(valobj_extractor, extract_error);
 
       if (!extract_error.Success()) {
         err.SetErrorStringWithFormat(
             "couldn't read contents of reference variable %s: %s",
-            m_variable_sp->GetName().AsCString(), extract_error.AsCString());
+            GetName().AsCString(), extract_error.AsCString());
         return;
       }
 
       lldb::offset_t offset = 0;
       lldb::addr_t reference_addr = valobj_extractor.GetAddress(&offset);
 
       Status write_error;
       map.WritePointerToMemory(load_addr, reference_addr, write_error);
 
       if (!write_error.Success()) {
         err.SetErrorStringWithFormat("couldn't write the contents of reference "
                                      "variable %s to memory: %s",
-                                     m_variable_sp->GetName().AsCString(),
+                                     GetName().AsCString(),
                                      write_error.AsCString());
         return;
       }
     } else {
       AddressType address_type = eAddressTypeInvalid;
       const bool scalar_is_load_address = false;
       lldb::addr_t addr_of_valobj =
           valobj_sp->GetAddressOf(scalar_is_load_address, &address_type);
       if (addr_of_valobj != LLDB_INVALID_ADDRESS) {
         Status write_error;
         map.WritePointerToMemory(load_addr, addr_of_valobj, write_error);
 
         if (!write_error.Success()) {
           err.SetErrorStringWithFormat(
               "couldn't write the address of variable %s to memory: %s",
-              m_variable_sp->GetName().AsCString(), write_error.AsCString());
+              GetName().AsCString(), write_error.AsCString());
           return;
         }
       } else {
         DataExtractor data;
         Status extract_error;
         valobj_sp->GetData(data, extract_error);
         if (!extract_error.Success()) {
           err.SetErrorStringWithFormat("couldn't get the value of %s: %s",
-                                       m_variable_sp->GetName().AsCString(),
+                                       GetName().AsCString(),
                                        extract_error.AsCString());
           return;
         }
 
         if (m_temporary_allocation != LLDB_INVALID_ADDRESS) {
           err.SetErrorStringWithFormat(
               "trying to create a temporary region for %s but one exists",
-              m_variable_sp->GetName().AsCString());
+              GetName().AsCString());
           return;
         }
 
-        if (data.GetByteSize() < m_variable_sp->GetType()->GetByteSize(scope)) {
-          if (data.GetByteSize() == 0 &&
-              !m_variable_sp->LocationExpressionList().IsValid()) {
+        if (data.GetByteSize() < GetByteSize(scope)) {
+          if (data.GetByteSize() == 0 && !LocationExpressionIsValid()) {
             err.SetErrorStringWithFormat("the variable '%s' has no location, "
                                          "it may have been optimized out",
-                                         m_variable_sp->GetName().AsCString());
+                                         GetName().AsCString());
           } else {
             err.SetErrorStringWithFormat(
                 "size of variable %s (%" PRIu64
                 ") is larger than the ValueObject's size (%" PRIu64 ")",
-                m_variable_sp->GetName().AsCString(),
-                m_variable_sp->GetType()->GetByteSize(scope).value_or(0),
+                GetName().AsCString(), GetByteSize(scope).value_or(0),
                 data.GetByteSize());
           }
           return;
         }
 
-        llvm::Optional<size_t> opt_bit_align =
-            m_variable_sp->GetType()->GetLayoutCompilerType().GetTypeBitAlign(scope);
+        llvm::Optional<size_t> opt_bit_align = GetTypeBitAlign(scope);
         if (!opt_bit_align) {
           err.SetErrorStringWithFormat("can't get the type alignment for %s",
-                                       m_variable_sp->GetName().AsCString());
+                                       GetName().AsCString());
           return;
         }
 
         size_t byte_align = (*opt_bit_align + 7) / 8;
 
         Status alloc_error;
         const bool zero_memory = false;
 
         m_temporary_allocation = map.Malloc(
             data.GetByteSize(), byte_align,
             lldb::ePermissionsReadable | lldb::ePermissionsWritable,
             IRMemoryMap::eAllocationPolicyMirror, zero_memory, alloc_error);
 
         m_temporary_allocation_size = data.GetByteSize();
 
         m_original_data = std::make_shared<DataBufferHeap>(data.GetDataStart(),
                                                            data.GetByteSize());
 
         if (!alloc_error.Success()) {
           err.SetErrorStringWithFormat(
               "couldn't allocate a temporary region for %s: %s",
-              m_variable_sp->GetName().AsCString(), alloc_error.AsCString());
+              GetName().AsCString(), alloc_error.AsCString());
           return;
         }
 
         Status write_error;
 
         map.WriteMemory(m_temporary_allocation, data.GetDataStart(),
                         data.GetByteSize(), write_error);
 
         if (!write_error.Success()) {
           err.SetErrorStringWithFormat(
               "couldn't write to the temporary region for %s: %s",
-              m_variable_sp->GetName().AsCString(), write_error.AsCString());
+              GetName().AsCString(), write_error.AsCString());
           return;
         }
 
         Status pointer_write_error;
 
         map.WritePointerToMemory(load_addr, m_temporary_allocation,
                                  pointer_write_error);
 
         if (!pointer_write_error.Success()) {
           err.SetErrorStringWithFormat(
               "couldn't write the address of the temporary region for %s: %s",
-              m_variable_sp->GetName().AsCString(),
-              pointer_write_error.AsCString());
+              GetName().AsCString(), pointer_write_error.AsCString());
         }
       }
     }
   }
 
   void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                      lldb::addr_t process_address, lldb::addr_t frame_top,
                      lldb::addr_t frame_bottom, Status &err) override {
     Log *log = GetLog(LLDBLog::Expressions);
 
     const lldb::addr_t load_addr = process_address + m_offset;
     if (log) {
       LLDB_LOGF(log,
                 "EntityVariable::Dematerialize [address = 0x%" PRIx64
                 ", m_variable_sp = %s]",
-                (uint64_t)load_addr, m_variable_sp->GetName().AsCString());
+                (uint64_t)load_addr, GetName().AsCString());
     }
 
     if (m_temporary_allocation != LLDB_INVALID_ADDRESS) {
       ExecutionContextScope *scope = frame_sp.get();
 
       if (!scope)
         scope = map.GetBestExecutionContextScope();
 
-      lldb::ValueObjectSP valobj_sp =
-          ValueObjectVariable::Create(scope, m_variable_sp);
+      lldb::ValueObjectSP valobj_sp = SetupValueObject(scope);
 
       if (!valobj_sp) {
         err.SetErrorStringWithFormat(
             "couldn't get a value object for variable %s",
-            m_variable_sp->GetName().AsCString());
+            GetName().AsCString());
         return;
       }
 
       lldb_private::DataExtractor data;
 
       Status extract_error;
 
       map.GetMemoryData(data, m_temporary_allocation,
                         valobj_sp->GetByteSize().value_or(0), extract_error);
 
       if (!extract_error.Success()) {
         err.SetErrorStringWithFormat("couldn't get the data for variable %s",
-                                     m_variable_sp->GetName().AsCString());
+                                     GetName().AsCString());
         return;
       }
 
       bool actually_write = true;
 
       if (m_original_data) {
         if ((data.GetByteSize() == m_original_data->GetByteSize()) &&
             !memcmp(m_original_data->GetBytes(), data.GetDataStart(),
                     data.GetByteSize())) {
           actually_write = false;
         }
       }
 
       Status set_error;
 
       if (actually_write) {
         valobj_sp->SetData(data, set_error);
 
         if (!set_error.Success()) {
           err.SetErrorStringWithFormat(
               "couldn't write the new contents of %s back into the variable",
-              m_variable_sp->GetName().AsCString());
+              GetName().AsCString());
           return;
         }
       }
 
       Status free_error;
 
       map.Free(m_temporary_allocation, free_error);
 
       if (!free_error.Success()) {
         err.SetErrorStringWithFormat(
             "couldn't free the temporary region for %s: %s",
-            m_variable_sp->GetName().AsCString(), free_error.AsCString());
+            GetName().AsCString(), free_error.AsCString());
         return;
       }
 
       m_original_data.reset();
       m_temporary_allocation = LLDB_INVALID_ADDRESS;
       m_temporary_allocation_size = 0;
     }
   }
if (m_temporary_allocation != LLDB_INVALID_ADDRESS) {
       map.Free(m_temporary_allocation, free_error);
 
       m_temporary_allocation = LLDB_INVALID_ADDRESS;
       m_temporary_allocation_size = 0;
     }
   }
 
 private:
-  lldb::VariableSP m_variable_sp;
+  virtual ConstString GetName() const = 0;
+
+  /// Creates and returns ValueObject tied to this variable
+  /// and prepares Entity for materialization.
+  ///
+  /// Called each time the Materializer (de)materializes a
+  /// variable. We re-create the ValueObject based on the
+  /// current ExecutionContextScope since clients such as
+  /// conditional breakpoints may materialize the same
+  /// EntityVariable multiple times with different frames.
+  ///
+  /// Each subsequent use of the EntityVariableBase interface
+  /// will query the newly created ValueObject until this
+  /// function is called again.
+  virtual lldb::ValueObjectSP
+  SetupValueObject(ExecutionContextScope *scope) = 0;
+
+  /// Returns size in bytes of the type associated with this variable
+  ///
+  /// \returns On success, returns byte size of the type associated
+  ///          with this variable. Returns NoneType otherwise.
+  virtual llvm::Optional<uint64_t>
+  GetByteSize(ExecutionContextScope *scope) const = 0;
+
+  /// Returns 'true' if the location expression associated with this variable
+  /// is valid.
+  virtual bool LocationExpressionIsValid() const = 0;
+
+  /// Returns alignment of the type associated with this variable in bits.
+  ///
+  /// \returns On success, returns alignment in bits for the type associated
+  ///          with this variable. Returns NoneType otherwise.
+  virtual llvm::Optional<size_t>
+  GetTypeBitAlign(ExecutionContextScope *scope) const = 0;
+
+protected:
   bool m_is_reference = false;
   lldb::addr_t m_temporary_allocation = LLDB_INVALID_ADDRESS;
   size_t m_temporary_allocation_size = 0;
   lldb::DataBufferSP m_original_data;
 };
 
+/// Represents an Entity constructed from a VariableSP.
+///
+/// This class is used for materialization of variables for which
+/// the user has a VariableSP on hand. The ValueObject is then
+/// derived from the associated DWARF location expression when needed
+/// by the Materializer.
+class EntityVariable : public EntityVariableBase {
+public:
+  EntityVariable(lldb::VariableSP &variable_sp) : m_variable_sp(variable_sp) {
+    m_is_reference =
+        m_variable_sp->GetType()->GetForwardCompilerType().IsReferenceType();
+  }
+
+  ConstString GetName() const override { return m_variable_sp->GetName(); }
+
+  lldb::ValueObjectSP SetupValueObject(ExecutionContextScope *scope) override {
+    assert(m_variable_sp != nullptr);
+    return ValueObjectVariable::Create(scope, m_variable_sp);
+  }
+
+  llvm::Optional<uint64_t>
+  GetByteSize(ExecutionContextScope *scope) const override {
+    return m_variable_sp->GetType()->GetByteSize(scope);
+  }
+
+  bool LocationExpressionIsValid() const override {
+    return m_variable_sp->LocationExpressionList().IsValid();
+  }
+
+  llvm::Optional<size_t>
+  GetTypeBitAlign(ExecutionContextScope *scope) const override {
+    return m_variable_sp->GetType()->GetLayoutCompilerType().GetTypeBitAlign(
+        scope);
+  }
+
+private:
+  lldb::VariableSP m_variable_sp; ///< Variable that this entity is based on.
+};
+
+/// Represents an Entity constructed from a VariableSP.
+///
+/// This class is used for materialization of variables for
+/// which the user does not have a VariableSP available (e.g.,
+/// when materializing ivars).
+class EntityValueObject : public EntityVariableBase {
+public:
+  EntityValueObject(ConstString name, ValueObjectProviderTy provider)
+      : m_name(name), m_valobj_provider(std::move(provider)) {
+    assert(m_valobj_provider);
+  }
+
+  ConstString GetName() const override { return m_name; }
+
+  lldb::ValueObjectSP SetupValueObject(ExecutionContextScope *scope) override {
+    m_valobj_sp =
+        m_valobj_provider(GetName(), scope->CalculateStackFrame().get());
+
+    if (m_valobj_sp)
+      m_is_reference = m_valobj_sp->GetCompilerType().IsReferenceType();
+
+    return m_valobj_sp;
+  }
+
+  llvm::Optional<uint64_t>
+  GetByteSize(ExecutionContextScope *scope) const override {
+    if (m_valobj_sp)
+      return m_valobj_sp->GetCompilerType().GetByteSize(scope);
+
+    return {};
+  }
+
+  bool LocationExpressionIsValid() const override {
+    if (m_valobj_sp)
+      return m_valobj_sp->GetError().Success();
+
+    return false;
+  }
+
+  llvm::Optional<size_t>
+  GetTypeBitAlign(ExecutionContextScope *scope) const override {
+    if (m_valobj_sp)
+      return m_valobj_sp->GetCompilerType().GetTypeBitAlign(scope);
+
+    return {};
+  }
+
+private:
+  ConstString m_name;
+  lldb::ValueObjectSP m_valobj_sp;
+  ValueObjectProviderTy m_valobj_provider;
+};
+
 uint32_t Materializer::AddVariable(lldb::VariableSP &variable_sp, Status &err) {
   EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
   *iter = std::make_unique<EntityVariable>(variable_sp);
   uint32_t ret = AddStructMember(**iter);
   (*iter)->SetOffset(ret);
   return ret;
 }
 
+uint32_t Materializer::AddValueObject(ConstString name,
+                                      ValueObjectProviderTy valobj_provider,
+                                      Status &err) {
+  assert(valobj_provider);
+  EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
+  *iter = std::make_unique<EntityValueObject>(name, std::move(valobj_provider));
+  uint32_t ret = AddStructMember(**iter);
+  (*iter)->SetOffset(ret);
+  return ret;
+}
+
 class EntityResultVariable : public Materializer::Entity {
 public:
   EntityResultVariable(const CompilerType &type, bool is_program_reference,
                        bool keep_in_memory,
                        Materializer::PersistentVariableDelegate *delegate)
       : Entity(), m_type(type), m_is_program_reference(is_program_reference),
         m_keep_in_memory(keep_in_memory), m_delegate(delegate) {
     // Hard-coding to maximum size of a pointer since all results are
     // materialized by reference
-    m_size = 8;
-    m_alignment = 8;
+    m_size = g_default_var_byte_size;
+    m_alignment = g_default_var_alignment;
   }
 
   void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                    lldb::addr_t process_address, Status &err) override {
     if (!m_is_program_reference) {
       if (m_temporary_allocation != LLDB_INVALID_ADDRESS) {
         err.SetErrorString("Trying to create a temporary region for the result "
                            "but one exists");
uint32_t Materializer::AddResultVariable(const CompilerType &type,
   (*iter)->SetOffset(ret);
   return ret;
 }
 
 class EntitySymbol : public Materializer::Entity {
 public:
   EntitySymbol(const Symbol &symbol) : Entity(), m_symbol(symbol) {
     // Hard-coding to maximum size of a symbol
-    m_size = 8;
-    m_alignment = 8;
+    m_size = g_default_var_byte_size;
+    m_alignment = g_default_var_alignment;
   }
 
   void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                    lldb::addr_t process_address, Status &err) override {
     Log *log = GetLog(LLDBLog::Expressions);
 
     const lldb::addr_t load_addr = process_address + m_offset;
 

lldb/source/Expression/UserExpression.cpp

 bool UserExpression::MatchesContext(ExecutionContext &exe_ctx) {
   lldb::TargetSP target_sp;
   lldb::ProcessSP process_sp;
   lldb::StackFrameSP frame_sp;
 
   return LockAndCheckContext(exe_ctx, target_sp, process_sp, frame_sp);
 }
 
-lldb::addr_t UserExpression::GetObjectPointer(lldb::StackFrameSP frame_sp,
-                                              ConstString &object_name,
-                                              Status &err) {
+lldb::ValueObjectSP UserExpression::GetObjectPointerValueObject(
+    lldb::StackFrameSP frame_sp, ConstString const &object_name, Status &err) {
   err.Clear();
 
   if (!frame_sp) {
     err.SetErrorStringWithFormat(
         "Couldn't load '%s' because the context is incomplete",
         object_name.AsCString());
-    return LLDB_INVALID_ADDRESS;
+    return {};
   }
 
   lldb::VariableSP var_sp;
   lldb::ValueObjectSP valobj_sp;
 
-  valobj_sp = frame_sp->GetValueForVariableExpressionPath(
+  return frame_sp->GetValueForVariableExpressionPath(
       object_name.GetStringRef(), lldb::eNoDynamicValues,
       StackFrame::eExpressionPathOptionCheckPtrVsMember |
           StackFrame::eExpressionPathOptionsNoFragileObjcIvar |
           StackFrame::eExpressionPathOptionsNoSyntheticChildren |
           StackFrame::eExpressionPathOptionsNoSyntheticArrayRange,
       var_sp, err);
+}
+
+lldb::addr_t UserExpression::GetObjectPointer(lldb::StackFrameSP frame_sp,
+                                              ConstString &object_name,
+                                              Status &err) {
+  auto valobj_sp =
+      GetObjectPointerValueObject(std::move(frame_sp), object_name, err);
 
   if (!err.Success() || !valobj_sp.get())
     return LLDB_INVALID_ADDRESS;
 
   lldb::addr_t ret = valobj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
 
   if (ret == LLDB_INVALID_ADDRESS) {
     err.SetErrorStringWithFormat(

lldb/source/Plugins/ExpressionParser/Clang/CMakeLists.txt

 add_lldb_library(lldbPluginExpressionParserClang
   ASTResultSynthesizer.cpp
   ASTStructExtractor.cpp
   ASTUtils.cpp
   ClangASTImporter.cpp
   ClangASTMetadata.cpp
   ClangASTSource.cpp
   ClangDeclVendor.cpp
   ClangExpressionDeclMap.cpp
   ClangExpressionParser.cpp
   ClangExpressionSourceCode.cpp
+  ClangExpressionUtil.cpp
   ClangExpressionVariable.cpp
   ClangExternalASTSourceCallbacks.cpp
   ClangFunctionCaller.cpp
   ClangHost.cpp
   ClangModulesDeclVendor.cpp
   ClangPersistentVariables.cpp
   ClangUserExpression.cpp
   ClangUtil.cpp

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h

private:
   /// \return
   ///     Return true if the value was successfully filled in.
   bool GetVariableValue(lldb::VariableSP &var,
                         lldb_private::Value &var_location,
                         TypeFromUser *found_type = nullptr,
                         TypeFromParser *parser_type = nullptr);
 
   /// Use the NameSearchContext to generate a Decl for the given LLDB
+  /// ValueObject, and put it in the list of found entities.
+  ///
+  /// Helper function used by the other AddOneVariable APIs.
+  ///
+  /// \param[in,out] context
+  ///     The NameSearchContext to use when constructing the Decl.
+  ///
+  /// \param[in] pt
+  ///     The CompilerType of the variable we're adding a Decl for.
+  ///
+  /// \param[in] var
+  ///     The LLDB ValueObject that needs a Decl.
+  ClangExpressionVariable::ParserVars *
+  AddExpressionVariable(NameSearchContext &context, TypeFromParser const &pt,
+                        lldb::ValueObjectSP valobj);
+
+  /// Use the NameSearchContext to generate a Decl for the given LLDB
   /// Variable, and put it in the Tuple list.
   ///
   /// \param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
   ///
   /// \param[in] var
   ///     The LLDB Variable that needs a Decl.
   ///
   /// \param[in] valobj
   ///     The LLDB ValueObject for that variable.
   void AddOneVariable(NameSearchContext &context, lldb::VariableSP var,
                       lldb::ValueObjectSP valobj);
 
+  /// Use the NameSearchContext to generate a Decl for the given ValueObject
+  /// and put it in the list of found entities.
+  ///
+  /// \param[in,out] context
+  ///     The NameSearchContext to use when constructing the Decl.
+  ///
+  /// \param[in] valobj
+  ///     The ValueObject that needs a Decl.
+  ///
+  /// \param[in] valobj_provider Callback that fetches a ValueObjectSP
+  ///            from the specified frame
+  void AddOneVariable(NameSearchContext &context, lldb::ValueObjectSP valobj,
+                      ValueObjectProviderTy valobj_provider);
+
   /// Use the NameSearchContext to generate a Decl for the given persistent
   /// variable, and put it in the list of found entities.
   ///
   /// \param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
   ///
   /// \param[in] pvar_sp
   ///     The persistent variable that needs a Decl.
   void AddOneVariable(NameSearchContext &context,
                       lldb::ExpressionVariableSP &pvar_sp);
 
   /// Use the NameSearchContext to generate a Decl for the given LLDB symbol
   /// (treated as a variable), and put it in the list of found entities.
   void AddOneGenericVariable(NameSearchContext &context, const Symbol &symbol);
 
   /// Use the NameSearchContext to generate a Decl for the given function.
   /// (Functions are not placed in the Tuple list.)  Can handle both fully
   /// typed functions and generic functions.
   ///
   /// \param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
   ///
   /// \param[in] fun
   ///     The Function that needs to be created.  If non-NULL, this is

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

 //===-- ClangExpressionDeclMap.cpp ----------------------------------------===//
 //
 // 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 "ClangExpressionDeclMap.h"
 
 #include "ClangASTSource.h"
+#include "ClangExpressionUtil.h"
+#include "ClangExpressionVariable.h"
 #include "ClangModulesDeclVendor.h"
 #include "ClangPersistentVariables.h"
 #include "ClangUtil.h"
 
+#include "NameSearchContext.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/Materializer.h"

 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
+#include "lldb/lldb-private-types.h"
 #include "lldb/lldb-private.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTImporter.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace clang;
 
 static const char *g_lldb_local_vars_namespace_cstr = "$__lldb_local_vars";
 
+namespace {
+/// A lambda is represented by Clang as an artifical class whose
+/// members are the lambda captures. If we capture a 'this' pointer,
+/// the artifical class will contain a member variable named 'this'.
+/// The function returns a ValueObject for the captured 'this' if such
+/// member exists. If no 'this' was captured, return a nullptr.
+lldb::ValueObjectSP GetCapturedThisValueObject(StackFrame *frame) {
+  assert(frame);
+
+  if (auto thisValSP = frame->FindVariable(ConstString("this")))
+    if (auto thisThisValSP =
+            thisValSP->GetChildMemberWithName(ConstString("this"), true))
+      return thisThisValSP;
+
+  return nullptr;
+}
+} // namespace
+
 ClangExpressionDeclMap::ClangExpressionDeclMap(
     bool keep_result_in_memory,
     Materializer::PersistentVariableDelegate *result_delegate,
     const lldb::TargetSP &target,
     const std::shared_ptr<ClangASTImporter> &importer, ValueObject *ctx_obj)
     : ClangASTSource(target, importer), m_found_entities(), m_struct_members(),
       m_keep_result_in_memory(keep_result_in_memory),
       m_result_delegate(result_delegate), m_ctx_obj(ctx_obj), m_parser_vars(),
if (m_parser_vars->m_materializer) {
     } else {
       if (const lldb_private::Symbol *sym = parser_vars->m_lldb_sym)
         offset = m_parser_vars->m_materializer->AddSymbol(*sym, err);
       else if (const RegisterInfo *reg_info = var->GetRegisterInfo())
         offset = m_parser_vars->m_materializer->AddRegister(*reg_info, err);
       else if (parser_vars->m_lldb_var)
         offset = m_parser_vars->m_materializer->AddVariable(
             parser_vars->m_lldb_var, err);
+      else if (parser_vars->m_lldb_valobj_provider) {
+        offset = m_parser_vars->m_materializer->AddValueObject(
+            name, parser_vars->m_lldb_valobj_provider, err);
+      }
     }
 
     if (!err.Success())
       return false;
 
     LLDB_LOG(log, "Placed at {0:x}", offset);
 
     jit_vars->m_offset =
void ClangExpressionDeclMap::LookUpLldbClass(NameSearchContext &context) {
 
   if (!function_decl_ctx)
     return;
 
   clang::CXXMethodDecl *method_decl =
       TypeSystemClang::DeclContextGetAsCXXMethodDecl(function_decl_ctx);
 
   if (method_decl) {
+    if (auto capturedThis = GetCapturedThisValueObject(frame)) {
+      // We're inside a lambda and we captured a 'this'.
+      // Import the outer class's AST instead of the
+      // (unnamed) lambda structure AST so unqualified
+      // member lookups are understood by the Clang parser.
+      //
+      // If we're in a lambda which didn't capture 'this',
+      // $__lldb_class will correspond to the lambda closure
+      // AST and references to captures will resolve like
+      // regular member varaiable accesses do.
+      TypeFromUser pointee_type =
+          capturedThis->GetCompilerType().GetPointeeType();
+
+      LLDB_LOG(log,
+               "  CEDM::FEVD Adding captured type ({0} for"
+               " $__lldb_class: {1}",
+               capturedThis->GetTypeName(), capturedThis->GetName());
+
+      AddContextClassType(context, pointee_type);
+      return;
+    }
+
     clang::CXXRecordDecl *class_decl = method_decl->getParent();
 
     QualType class_qual_type(class_decl->getTypeForDecl(), 0);
 
     TypeFromUser class_user_type(class_qual_type.getAsOpaquePtr(),
                                  function_decl_ctx.GetTypeSystem());
 
     LLDB_LOG(log, "  CEDM::FEVD Adding type for $__lldb_class: {0}",
for (CompilerDecl decl : found_decls) {
 
     if (var && !variable_found) {
       variable_found = true;
       ValueObjectSP valobj = ValueObjectVariable::Create(frame, var);
       AddOneVariable(context, var, valobj);
       context.m_found_variable = true;
     }
   }
+
+  // We're in a local_var_lookup but haven't found any local variables
+  // so far. When performing a variable lookup from within the context of
+  // a lambda, we count the lambda captures as local variables. Thus,
+  // see if we captured any variables with the requested 'name'.
+  if (!variable_found) {
+    auto find_capture = [](ConstString varname,
+                           StackFrame *frame) -> ValueObjectSP {
+      if (auto lambda = ClangExpressionUtil::GetLambdaValueObject(frame)) {
+        if (auto capture = lambda->GetChildMemberWithName(varname, true)) {
+          return capture;
+        }
+      }
+
+      return nullptr;
+    };
+
+    if (auto capture = find_capture(name, frame)) {
+      variable_found = true;
+      context.m_found_variable = true;
+      AddOneVariable(context, std::move(capture), std::move(find_capture));
+    }
+  }
+
   return variable_found;
 }
 
 /// Structure to hold the info needed when comparing function
 /// declarations.
 namespace {
 struct FuncDeclInfo {
   ConstString m_name;
bool ClangExpressionDeclMap::GetVariableValue(VariableSP &var,
   }
 
   if (user_type)
     *user_type = TypeFromUser(var_clang_type);
 
   return true;
 }
 
-void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
-                                            VariableSP var,
+ClangExpressionVariable::ParserVars *
+ClangExpressionDeclMap::AddExpressionVariable(NameSearchContext &context,
+                                              TypeFromParser const &pt,
                                               ValueObjectSP valobj) {
-  assert(m_parser_vars.get());
-
-  Log *log = GetLog(LLDBLog::Expressions);
-
-  TypeFromUser ut;
-  TypeFromParser pt;
-  Value var_location;
-
-  if (!GetVariableValue(var, var_location, &ut, &pt))
-    return;
-
   clang::QualType parser_opaque_type =
       QualType::getFromOpaquePtr(pt.GetOpaqueQualType());
 
   if (parser_opaque_type.isNull())
-    return;
+    return nullptr;
 
   if (const clang::Type *parser_type = parser_opaque_type.getTypePtr()) {
     if (const TagType *tag_type = dyn_cast<TagType>(parser_type))
       CompleteType(tag_type->getDecl());
     if (const ObjCObjectPointerType *objc_object_ptr_type =
             dyn_cast<ObjCObjectPointerType>(parser_type))
       CompleteType(objc_object_ptr_type->getInterfaceDecl());
   }
ClangExpressionDeclMap::AddExpressionVariable(NameSearchContext &context,
   ConstString entity_name(decl_name.c_str());
   ClangExpressionVariable *entity(new ClangExpressionVariable(valobj));
   m_found_entities.AddNewlyConstructedVariable(entity);
 
   assert(entity);
   entity->EnableParserVars(GetParserID());
   ClangExpressionVariable::ParserVars *parser_vars =
       entity->GetParserVars(GetParserID());
+
   parser_vars->m_named_decl = var_decl;
-  parser_vars->m_llvm_value = nullptr;
-  parser_vars->m_lldb_value = var_location;
-  parser_vars->m_lldb_var = var;
 
   if (is_reference)
     entity->m_flags |= ClangExpressionVariable::EVTypeIsReference;
 
+  return parser_vars;
+}
+
+void ClangExpressionDeclMap::AddOneVariable(
+    NameSearchContext &context, ValueObjectSP valobj,
+    ValueObjectProviderTy valobj_provider) {
+  assert(m_parser_vars.get());
+  assert(valobj);
+
+  Log *log = GetLog(LLDBLog::Expressions);
+
+  Value var_location = valobj->GetValue();
+
+  TypeFromUser user_type = valobj->GetCompilerType();
+
+  TypeSystemClang *clang_ast =
+      llvm::dyn_cast_or_null<TypeSystemClang>(user_type.GetTypeSystem());
+
+  if (!clang_ast) {
+    LLDB_LOG(log, "Skipped a definition because it has no Clang AST");
+    return;
+  }
+
+  TypeFromParser parser_type = GuardedCopyType(user_type);
+
+  if (!parser_type) {
+    LLDB_LOG(log,
+             "Couldn't copy a variable's type into the parser's AST context");
+
+    return;
+  }
+
+  if (var_location.GetContextType() == Value::ContextType::Invalid)
+    var_location.SetCompilerType(parser_type);
+
+  ClangExpressionVariable::ParserVars *parser_vars =
+      AddExpressionVariable(context, parser_type, valobj);
+
+  if (!parser_vars)
+    return;
+
+  LLDB_LOG(log, "  CEDM::FEVD Found variable {0}, returned\n{1} (original {2})",
+           context.m_decl_name, ClangUtil::DumpDecl(parser_vars->m_named_decl),
+           ClangUtil::ToString(user_type));
+
+  parser_vars->m_llvm_value = nullptr;
+  parser_vars->m_lldb_value = std::move(var_location);
+  parser_vars->m_lldb_valobj_provider = std::move(valobj_provider);
+}
+
+void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
+                                            VariableSP var,
+                                            ValueObjectSP valobj) {
+  assert(m_parser_vars.get());
+
+  Log *log = GetLog(LLDBLog::Expressions);
+
+  TypeFromUser ut;
+  TypeFromParser pt;
+  Value var_location;
+
+  if (!GetVariableValue(var, var_location, &ut, &pt))
+    return;
+
+  ClangExpressionVariable::ParserVars *parser_vars =
+      AddExpressionVariable(context, pt, std::move(valobj));
+
+  if (!parser_vars)
+    return;
+
   LLDB_LOG(log, "  CEDM::FEVD Found variable {0}, returned\n{1} (original {2})",
-           decl_name, ClangUtil::DumpDecl(var_decl), ClangUtil::ToString(ut));
+           context.m_decl_name, ClangUtil::DumpDecl(parser_vars->m_named_decl),
+           ClangUtil::ToString(ut));
+
+  parser_vars->m_llvm_value = nullptr;
+  parser_vars->m_lldb_value = var_location;
+  parser_vars->m_lldb_var = var;
 }
 
 void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
                                             ExpressionVariableSP &pvar_sp) {
   Log *log = GetLog(LLDBLog::Expressions);
 
   TypeFromUser user_type(
       llvm::cast<ClangExpressionVariable>(pvar_sp.get())->GetTypeFromUser());
 
   TypeFromParser parser_type(GuardedCopyType(user_type));
 
   if (!parser_type.GetOpaqueQualType()) {
     LLDB_LOG(log, "  CEDM::FEVD Couldn't import type for pvar {0}",

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.h

bool GetOriginalBodyBounds(std::string transformed_text,
                              size_t &start_loc, size_t &end_loc);
 
 protected:
   ClangExpressionSourceCode(llvm::StringRef filename, llvm::StringRef name,
                             llvm::StringRef prefix, llvm::StringRef body,
                             Wrapping wrap, WrapKind wrap_kind);
 
 private:
-  void AddLocalVariableDecls(const lldb::VariableListSP &var_list_sp,
-                             StreamString &stream,
-                             const std::string &expr) const;
+  /// Writes "using" declarations for local variables into the specified stream.
+  ///
+  /// Behaviour is undefined if 'frame == nullptr'.
+  ///
+  /// \param[out] stream Stream that this function generates "using"
+  ///             declarations into.
+  ///
+  /// \param[in]  expr Expression source that we're evaluating.
+  ///
+  /// \param[in]  frame StackFrame which carries information about the local
+  ///             variables that we're generating "using" declarations for.
+  void AddLocalVariableDecls(StreamString &stream, const std::string &expr,
+                             StackFrame *frame) const;
 
   /// String marking the start of the user expression.
   std::string m_start_marker;
   /// String marking the end of the user expression.
   std::string m_end_marker;
   /// How the expression has been wrapped.
   const WrapKind m_wrap_kind;
 };
 
 } // namespace lldb_private
 
 #endif

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp

 //===-- ClangExpressionSourceCode.cpp -------------------------------------===//
 //
 // 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 "ClangExpressionSourceCode.h"
 
+#include "ClangExpressionUtil.h"
+
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/StringRef.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/lldb-forward.h"
 
 using namespace lldb_private;
 
 #define PREFIX_NAME "<lldb wrapper prefix>"
 #define SUFFIX_NAME "<lldb wrapper suffix>"
 
 const llvm::StringRef ClangExpressionSourceCode::g_prefix_file_name = PREFIX_NAME;
 

 public:
   TokenVerifier(std::string body);
   /// Returns true iff the given expression body contained a token with the
   /// given content.
   bool hasToken(llvm::StringRef token) const {
     return m_tokens.find(token) != m_tokens.end();
   }
 };
+
+// If we're evaluating from inside a lambda that captures a 'this' pointer,
+// add a "using" declaration to 'stream' for each capture used in the
+// expression (tokenized by 'verifier').
+//
+// If no 'this' capture exists, generate no using declarations. Instead
+// capture lookups will get resolved by the same mechanism as class member
+// variable lookup. That's because Clang generates an unnamed structure
+// representing the lambda closure whose members are the captured variables.
+void AddLambdaCaptureDecls(StreamString &stream, StackFrame *frame,
+                           TokenVerifier const &verifier) {
+  assert(frame);
+
+  if (auto thisValSP = ClangExpressionUtil::GetLambdaValueObject(frame)) {
+    uint32_t numChildren = thisValSP->GetNumChildren();
+    for (uint32_t i = 0; i < numChildren; ++i) {
+      auto childVal = thisValSP->GetChildAtIndex(i, true);
+      ConstString childName(childVal ? childVal->GetName() : ConstString(""));
+
+      if (!childName.IsEmpty() && verifier.hasToken(childName.GetStringRef()) &&
+          childName != "this") {
+        stream.Printf("using $__lldb_local_vars::%s;\n",
+                      childName.GetCString());
+      }
+    }
+  }
+}
+
 } // namespace
 
 TokenVerifier::TokenVerifier(std::string body) {
   using namespace clang;
 
   // We only care about tokens and not their original source locations. If we
   // move the whole expression to only be in one line we can simplify the
   // following code that extracts the token contents.
while (!exit) {
     // Extract the token string from our source code and store it.
     std::string token_str = body.substr(start, token.getLength());
     if (token_str.empty())
       continue;
     m_tokens.insert(token_str);
   }
 }
 
-void ClangExpressionSourceCode::AddLocalVariableDecls(
-    const lldb::VariableListSP &var_list_sp, StreamString &stream,
-    const std::string &expr) const {
+void ClangExpressionSourceCode::AddLocalVariableDecls(StreamString &stream,
+                                                      const std::string &expr,
+                                                      StackFrame *frame) const {
+  assert(frame);
   TokenVerifier tokens(expr);
 
+  lldb::VariableListSP var_list_sp = frame->GetInScopeVariableList(false, true);
+
   for (size_t i = 0; i < var_list_sp->GetSize(); i++) {
     lldb::VariableSP var_sp = var_list_sp->GetVariableAtIndex(i);
 
     ConstString var_name = var_sp->GetName();
 
+    if (var_name == "this" && m_wrap_kind == WrapKind::CppMemberFunction) {
+      AddLambdaCaptureDecls(stream, frame, tokens);
+
+      continue;
+    }
 
     // We can check for .block_descriptor w/o checking for langauge since this
     // is not a valid identifier in either C or C++.
     if (!var_name || var_name == ".block_descriptor")
       continue;
 
     if (!expr.empty() && !tokens.hasToken(var_name.GetStringRef()))
       continue;
 
     const bool is_objc = m_wrap_kind == WrapKind::ObjCInstanceMethod ||
                          m_wrap_kind == WrapKind::ObjCStaticMethod;
     if ((var_name == "self" || var_name == "_cmd") && is_objc)
       continue;
 
-    if (var_name == "this" && m_wrap_kind == WrapKind::CppMemberFunction)
-      continue;
-
     stream.Printf("using $__lldb_local_vars::%s;\n", var_name.AsCString());
   }
 }
 
 bool ClangExpressionSourceCode::GetText(
     std::string &text, ExecutionContext &exe_ctx, bool add_locals,
     bool force_add_all_locals, llvm::ArrayRef<std::string> modules) const {
   const char *target_specific_defines = "typedef signed char BOOL;\n";
if (sc.comp_unit && sc.line_entry.IsValid()) {
       if (dm) {
         AddMacroState state(sc.line_entry.file, sc.line_entry.line);
         AddMacros(dm, sc.comp_unit, state, debug_macros_stream);
       }
     }
 
     if (add_locals)
       if (target->GetInjectLocalVariables(&exe_ctx)) {
-        lldb::VariableListSP var_list_sp =
-            frame->GetInScopeVariableList(false, true);
-        AddLocalVariableDecls(var_list_sp, lldb_local_var_decls,
-                              force_add_all_locals ? "" : m_body);
+        AddLocalVariableDecls(lldb_local_var_decls,
+                              force_add_all_locals ? "" : m_body, frame);
       }
   }
 
   if (m_wrap) {
     // Generate a list of @import statements that will import the specified
     // module into our expression.
     std::string module_imports;
     for (const std::string &module : modules) {

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionUtil.h

+//===-- ClangExpressionUtil.h -----------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONUTIL_H
+#define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONUTIL_H
+
+#include "lldb/lldb-private.h"
+
+namespace lldb_private {
+namespace ClangExpressionUtil {
+/// Returns a ValueObject for the lambda class in the current frame
+///
+/// To represent a lambda, Clang generates an artificial class
+/// whose members are the captures and whose operator() is the
+/// lambda implementation. If we capture a 'this' pointer,
+/// the artifical class will contain a member variable named 'this'.
+///
+/// This method returns the 'this' pointer to the artificial lambda
+/// class if a real 'this' was captured. Otherwise, returns nullptr.
+lldb::ValueObjectSP GetLambdaValueObject(StackFrame *frame);
+
+} // namespace ClangExpressionUtil
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONHELPER_H

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionUtil.cpp

+//===-- ClangExpressionUtil.cpp -------------------------------------------===//
+//
+// 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 "ClangExpressionUtil.h"
+
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Target/StackFrame.h"
+#include "lldb/Utility/ConstString.h"
+
+namespace lldb_private {
+namespace ClangExpressionUtil {
+lldb::ValueObjectSP GetLambdaValueObject(StackFrame *frame) {
+  assert(frame);
+
+  if (auto this_val_sp = frame->FindVariable(ConstString("this")))
+    if (this_val_sp->GetChildMemberWithName(ConstString("this"), true))
+      return this_val_sp;
+
+  return nullptr;
+}
+} // namespace ClangExpressionUtil
+} // namespace lldb_private

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h

public:
   /// \return
   ///     True on success; false otherwise (in particular, if this variable
   ///     does not contain its own data).
   bool PointValueAtData(Value &value, ExecutionContext *exe_ctx);
 
   /// The following values should not live beyond parsing
   class ParserVars {
   public:
-    ParserVars() : m_lldb_value(), m_lldb_var() {}
+    ParserVars() = default;
 
     const clang::NamedDecl *m_named_decl =
         nullptr; ///< The Decl corresponding to this variable
     llvm::Value *m_llvm_value =
         nullptr; ///< The IR value corresponding to this variable;
                  /// usually a GlobalValue
     lldb_private::Value
         m_lldb_value;            ///< The value found in LLDB for this variable
     lldb::VariableSP m_lldb_var; ///< The original variable for this variable
     const lldb_private::Symbol *m_lldb_sym =
         nullptr; ///< The original symbol for this
                  /// variable, if it was a symbol
+
+    /// Callback that provides a ValueObject for the
+    /// specified frame. Used by the materializer for
+    /// re-fetching ValueObjects when materializing
+    /// ivars.
+    ValueObjectProviderTy m_lldb_valobj_provider;
   };
 
 private:
   typedef std::map<uint64_t, ParserVars> ParserVarMap;
   ParserVarMap m_parser_vars;
 
 public:
   /// Make this variable usable by the parser by allocating space for parser-

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

private:
   bool AddArguments(ExecutionContext &exe_ctx, std::vector<lldb::addr_t> &args,
                     lldb::addr_t struct_address,
                     DiagnosticManager &diagnostic_manager) override;
 
   void CreateSourceCode(DiagnosticManager &diagnostic_manager,
                         ExecutionContext &exe_ctx,
                         std::vector<std::string> modules_to_import,
                         bool for_completion);
+
+  lldb::addr_t GetCppObjectPointer(lldb::StackFrameSP frame,
+                                   ConstString &object_name, Status &err);
+
   /// Defines how the current expression should be wrapped.
   ClangExpressionSourceCode::WrapKind GetWrapKind() const;
   bool SetupPersistentState(DiagnosticManager &diagnostic_manager,
                                    ExecutionContext &exe_ctx);
   bool PrepareForParsing(DiagnosticManager &diagnostic_manager,
                          ExecutionContext &exe_ctx, bool for_completion);
 
   ClangUserExpressionHelper m_type_system_helper;

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

bool ClangUserExpression::Complete(ExecutionContext &exe_ctx,
   // The actual column where we have to complete is the start column of the
   // user expression + the offset inside the user code that we were given.
   const unsigned completion_column = user_expr_column + complete_pos;
   parser.Complete(request, user_expr_line, completion_column, complete_pos);
 
   return true;
 }
 
+lldb::addr_t ClangUserExpression::GetCppObjectPointer(
+    lldb::StackFrameSP frame_sp, ConstString &object_name, Status &err) {
+  auto valobj_sp =
+      GetObjectPointerValueObject(std::move(frame_sp), object_name, err);
+
+  // We're inside a C++ class method. This could potentially be an unnamed
+  // lambda structure. If the lambda captured a "this", that should be
+  // the object pointer.
+  if (auto thisChildSP =
+          valobj_sp->GetChildMemberWithName(ConstString("this"), true)) {
+    valobj_sp = thisChildSP;
+  }
+
+  if (!err.Success() || !valobj_sp.get())
+    return LLDB_INVALID_ADDRESS;
+
+  lldb::addr_t ret = valobj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
+
+  if (ret == LLDB_INVALID_ADDRESS) {
+    err.SetErrorStringWithFormat(
+        "Couldn't load '%s' because its value couldn't be evaluated",
+        object_name.AsCString());
+    return LLDB_INVALID_ADDRESS;
+  }
+
+  return ret;
+}
+
 bool ClangUserExpression::AddArguments(ExecutionContext &exe_ctx,
                                        std::vector<lldb::addr_t> &args,
                                        lldb::addr_t struct_address,
                                        DiagnosticManager &diagnostic_manager) {
   lldb::addr_t object_ptr = LLDB_INVALID_ADDRESS;
   lldb::addr_t cmd_ptr = LLDB_INVALID_ADDRESS;
 
   if (m_needs_object_ptr) {
if (m_needs_object_ptr) {
 
     if (m_ctx_obj) {
       AddressType address_type;
       object_ptr = m_ctx_obj->GetAddressOf(false, &address_type);
       if (object_ptr == LLDB_INVALID_ADDRESS ||
           address_type != eAddressTypeLoad)
         object_ptr_error.SetErrorString("Can't get context object's "
                                         "debuggee address");
-    } else
+    } else {
+      if (m_in_cplusplus_method) {
+        object_ptr =
+            GetCppObjectPointer(frame_sp, object_name, object_ptr_error);
+      } else {
         object_ptr = GetObjectPointer(frame_sp, object_name, object_ptr_error);
+      }
+    }
 
     if (!object_ptr_error.Success()) {
       exe_ctx.GetTargetRef().GetDebugger().GetAsyncOutputStream()->Printf(
           "warning: `%s' is not accessible (substituting 0). %s\n",
           object_name.AsCString(), object_ptr_error.AsCString());
       object_ptr = 0;
     }
 

lldb/test/API/commands/expression/expr_inside_lambda/Makefile

+CXX_SOURCES := main.cpp
+
+CXXFLAGS_EXTRAS := -std=c++14 -O0 -g
+
+include Makefile.rules

lldb/test/API/commands/expression/expr_inside_lambda/TestExprInsideLambdas.py

+""" Test that evaluating expressions from within C++ lambdas works
+    Particularly, we test the case of capturing "this" and
+    using members of the captured object in expression evaluation
+    while we're on a breakpoint inside a lambda.
+"""
+
+
+import lldb
+from lldbsuite.test.lldbtest import *
+
+
+class ExprInsideLambdaTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def expectExprError(self, expr : str, expected : str):
+        frame = self.thread.GetFrameAtIndex(0)
+        value = frame.EvaluateExpression(expr)
+        errmsg = value.GetError().GetCString()
+        self.assertIn(expected, errmsg)
+
+    def test_expr_inside_lambda(self):
+        """Test that lldb evaluating expressions inside lambda expressions works correctly."""
+        self.build()
+        (target, process, self.thread, bkpt) = \
+                lldbutil.run_to_source_breakpoint(self, "break here", lldb.SBFileSpec("main.cpp"))
+
+        # Inside 'Foo::method'
+
+        # Check access to captured 'this'
+        self.expect_expr("class_var", result_type="int", result_value="109")
+        self.expect_expr("this->class_var", result_type="int", result_value="109")
+
+        # Check that captured shadowed variables take preference over the
+        # corresponding member variable
+        self.expect_expr("shadowed", result_type="int", result_value="5")
+        self.expect_expr("this->shadowed", result_type="int", result_value="-137")
+
+        # Check access to local captures
+        self.expect_expr("local_var", result_type="int", result_value="137")
+        self.expect_expr("*class_ptr", result_type="int", result_value="137")
+
+        # Check access to base class variables
+        self.expect_expr("base_var", result_type="int", result_value="14")
+        self.expect_expr("base_base_var", result_type="int", result_value="11")
+
+        # Check access to global variable
+        self.expect_expr("global_var", result_type="int", result_value="-5")
+
+        # Check access to multiple captures/member variables
+        self.expect_expr("(shadowed + this->shadowed) * (base_base_var + local_var - class_var)",
+                         result_type="int", result_value="-5148")
+
+        # Check base-class function call
+        self.expect_expr("baz_virt()", result_type="int", result_value="2")
+        self.expect_expr("base_var", result_type="int", result_value="14")
+        self.expect_expr("this->shadowed", result_type="int", result_value="-1")
+        
+        # 'p this' should yield 'struct Foo*'
+        frame = self.thread.GetFrameAtIndex(0)
+        outer_class_addr = frame.GetValueForVariablePath("this->this")
+        self.expect_expr("this", result_value=outer_class_addr.GetValue())
+
+        lldbutil.continue_to_breakpoint(process, bkpt)
+
+        # Inside 'nested_lambda'
+        
+        # Check access to captured 'this'. Should still be 'struct Foo*'
+        self.expect_expr("class_var", result_type="int", result_value="109")
+        self.expect_expr("global_var", result_type="int", result_value="-5")
+        self.expect_expr("this", result_value=outer_class_addr.GetValue())
+
+        # Check access to captures
+        self.expect_expr("lambda_local_var", result_type="int", result_value="5")
+        self.expect_expr("local_var", result_type="int", result_value="137")
+
+        # Check access to variable in previous frame which we didn't capture
+        self.expectExprError("local_var_copy", "use of undeclared identifier")
+
+        lldbutil.continue_to_breakpoint(process, bkpt)
+
+        # By-ref mutates source variable
+        self.expect_expr("lambda_local_var", result_type="int", result_value="0")
+
+        # By-value doesn't mutate source variable
+        self.expect_expr("local_var_copy", result_type="int", result_value="136")
+        self.expect_expr("local_var", result_type="int", result_value="137")
+
+        lldbutil.continue_to_breakpoint(process, bkpt)
+
+        # Inside 'LocalLambdaClass::inner_method'
+
+        # Check access to captured 'this'
+        self.expect_expr("lambda_class_local", result_type="int", result_value="-12345")
+        self.expect_expr("this->lambda_class_local", result_type="int", result_value="-12345")
+        self.expect_expr("outer_ptr->class_var", result_type="int", result_value="109")
+
+        # 'p this' should yield 'struct LocalLambdaClass*'
+        frame = self.thread.GetFrameAtIndex(0)
+        local_class_addr = frame.GetValueForVariablePath("this->this")
+        self.assertNotEqual(local_class_addr, outer_class_addr)
+        self.expect_expr("this", result_value=local_class_addr.GetValue())
+
+        # Can still access global variable
+        self.expect_expr("global_var", result_type="int", result_value="-5")
+
+        # Check access to outer top-level structure's members
+        self.expectExprError("class_var", ("use of non-static data member"
+                                           " 'class_var' of 'Foo' from nested type"))
+
+        self.expectExprError("base_var", ("use of non-static data member"
+                                           " 'base_var'"))
+
+        self.expectExprError("local_var", ("use of non-static data member 'local_var'"
+                                           " of '' from nested type 'LocalLambdaClass'"))
+
+        # Inside non_capturing_method
+        lldbutil.continue_to_breakpoint(process, bkpt)
+        self.expect_expr("local", result_type="int", result_value="5")
+        self.expect_expr("local2", result_type="int", result_value="10")
+        self.expect_expr("local2 * local", result_type="int", result_value="50")
+
+        self.expectExprError("class_var", ("use of non-static data member"
+                                           " 'class_var' of 'Foo' from nested type"))

lldb/test/API/commands/expression/expr_inside_lambda/main.cpp

+#include <cassert>
+#include <cstdio>
+
+namespace {
+int global_var = -5;
+} // namespace
+
+struct Baz {
+  virtual ~Baz() = default;
+
+  virtual int baz_virt() = 0;
+
+  int base_base_var = 12;
+};
+
+struct Bar : public Baz {
+  virtual ~Bar() = default;
+
+  virtual int baz_virt() override {
+    base_var = 10;
+    return 1;
+  }
+
+  int base_var = 15;
+};
+
+struct Foo : public Bar {
+  int class_var = 9;
+  int shadowed = -137;
+  int *class_ptr;
+
+  virtual ~Foo() = default;
+
+  virtual int baz_virt() override {
+    shadowed = -1;
+    return 2;
+  }
+
+  void method() {
+    int local_var = 137;
+    int shadowed;
+    class_ptr = &local_var;
+    auto lambda = [&shadowed, this, &local_var,
+                   local_var_copy = local_var]() mutable {
+      int lambda_local_var = 5;
+      shadowed = 5;
+      class_var = 109;
+      --base_var;
+      --base_base_var;
+      std::puts("break here");
+
+      auto nested_lambda = [this, &lambda_local_var, local_var] {
+        std::puts("break here");
+        lambda_local_var = 0;
+      };
+
+      nested_lambda();
+      --local_var_copy;
+      std::puts("break here");
+
+      struct LocalLambdaClass {
+        int lambda_class_local = -12345;
+        Foo *outer_ptr;
+
+        void inner_method() {
+          auto lambda = [this] {
+            std::puts("break here");
+            lambda_class_local = -2;
+            outer_ptr->class_var *= 2;
+          };
+
+          lambda();
+        }
+      };
+
+      LocalLambdaClass l;
+      l.outer_ptr = this;
+      l.inner_method();
+    };
+    lambda();
+  }
+
+  void non_capturing_method() {
+    int local = 5;
+    int local2 = 10;
+
+    class_var += [=] {
+      std::puts("break here");
+      return local + local2;
+    }();
+  }
+};
+
+int main() {
+  Foo f;
+  f.method();
+  f.non_capturing_method();
+  return global_var;
+}

lldb/test/API/functionalities/breakpoint/breakpoint_on_lambda_capture/Makefile

+CXX_SOURCES := main.cpp
+ENABLE_THREADS := YES
+
+include Makefile.rules

lldb/test/API/functionalities/breakpoint/breakpoint_on_lambda_capture/TestBreakOnLambdaCapture.py

+"""
+Test that if we hit a breakpoint on a lambda capture
+on two threads at the same time we stop only for
+the correct one.
+"""
+
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+
+
+class TestBreakOnLambdaCapture(TestBase):
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def test_break_on_lambda_capture(self):
+        self.build()
+        self.main_source_file = lldb.SBFileSpec("main.cpp")
+
+        (target, process, main_thread, _) = lldbutil.run_to_source_breakpoint(self,
+                                                "First break", self.main_source_file)
+
+        # FIXME: This is working around a separate bug. If you hit a breakpoint and
+        # run an expression and it is the first expression you've ever run, on
+        # Darwin that will involve running the ObjC runtime parsing code, and we'll
+        # be in the middle of that when we do PerformAction on the other thread,
+        # which will cause the condition expression to fail.  Calling another
+        # expression first works around this.
+        val_obj = main_thread.frame[0].EvaluateExpression("true")
+        self.assertSuccess(val_obj.GetError(), "Ran our expression successfully")
+        self.assertEqual(val_obj.value, "true", "Value was true.")
+
+        bkpt = target.BreakpointCreateBySourceRegex("Break here in the helper",
+                                                    self.main_source_file);
+
+        bkpt.SetCondition("enable && usec == 1")
+        process.Continue()
+
+        # This is hard to test definitively, becuase it requires hitting
+        # a breakpoint on multiple threads at the same time.  On Darwin, this
+        # will happen pretty much ever time we continue.  What we are really
+        # asserting is that we only ever stop on one thread, so we approximate that
+        # by continuing 20 times and assert we only ever hit the first thread.  Either
+        # this is a platform that only reports one hit at a time, in which case all
+        # this code is unused, or we actually didn't hit the other thread.
+
+        for idx in range(0, 20):
+            process.Continue()
+            for thread in process.threads:
+                if thread.id == main_thread.id:
+                    self.assertEqual(thread.stop_reason, lldb.eStopReasonBreakpoint)
+                else:
+                    self.assertEqual(thread.stop_reason, lldb.eStopReasonNone)

lldb/test/API/functionalities/breakpoint/breakpoint_on_lambda_capture/main.cpp

+#include <chrono>
+#include <cstdio>
+#include <thread>
+
+struct Foo {
+  bool enable = true;
+  uint32_t offset = 0;
+
+  void usleep_helper(uint32_t usec) {
+    [this, &usec] {
+      puts("Break here in the helper");
+      std::this_thread::sleep_for(
+          std::chrono::duration<unsigned int, std::milli>(offset + usec));
+    }();
+  }
+};
+
+void *background_thread(void *) {
+  Foo f;
+  for (;;) {
+    f.usleep_helper(2);
+  }
+}
+
+int main() {
+  std::puts("First break");
+  std::thread main_thread(background_thread, nullptr);
+  Foo f;
+  for (;;) {
+    f.usleep_helper(1);
+  }
+}