[lldb][Commands] Fix memory find for Swift expressions

There were two issues previously preventing `memory find -e` expressions
to succeed when stopped in Swift frames:
1. We weren't getting the dynamic type of the result `ValueObject`.
   For Swift this would fail when we tried to produce a scalar value
   out of it because the static VO wasn't sufficient to get to the
   integer value. Hence we add a call to `GetQualifiedRepresentationIfAvailable`
   (which is what we do for expressions in `OptionArgParser::ToAddress` too).
2. We weren't passing an `ExecutionContextScope` to `GetByteSize`, which
   Swift relied on to get the size of the result type.

My plan is to add an API test for this on the Apple `swiftlang/llvm-project` fork.

I considered an alternative where we use `OptionArgParser::ToAddress`
for `memory find -e` expressions, but it got a bit icky when trying to
figure out how many bytes we should copy out of the result into the
`DataBufferHeap` (currently we rely on the size of the result variable
type). This gets even trickier when we were to pass an expression that
was actually a hex digit or a number into `ToAddress`.

rdar://152113525

Author: Michael137

lldb/source/Commands/CommandObjectMemory.cpp

@@ -886,9 +886,10 @@ class CommandObjectMemoryRead : public CommandObjectParsed {
 #include "CommandOptions.inc"
 
 static llvm::Error CopyExpressionResult(ValueObject &result,
-                                        DataBufferHeap &buffer) {
+                                        DataBufferHeap &buffer,
+                                        ExecutionContextScope *scope) {
   uint64_t value = result.GetValueAsUnsigned(0);
-  auto size_or_err = result.GetCompilerType().GetByteSize(nullptr);
+  auto size_or_err = result.GetCompilerType().GetByteSize(scope);
   if (!size_or_err)
     return size_or_err.takeError();
 
@@ -931,6 +932,11 @@ EvaluateExpression(llvm::StringRef expression, StackFrame &frame,
     return llvm::createStringError(
         "expression evaluation failed. pass a string instead");
 
+  result_sp = result_sp->GetQualifiedRepresentationIfAvailable(
+      result_sp->GetDynamicValueType(), /*synthValue=*/true);
+  if (!result_sp)
+    return llvm::createStringError("failed to unwrap expression result type");
+
   return result_sp;
 }
 
@@ -1085,7 +1091,8 @@ class CommandObjectMemoryFind : public CommandObjectParsed {
 
       ValueObjectSP result_sp = *result_or_err;
 
-      if (auto err = CopyExpressionResult(*result_sp, buffer)) {
+      if (auto err = CopyExpressionResult(*result_sp, buffer,
+                                          m_exe_ctx.GetFramePtr())) {
         result.AppendError(llvm::toString(std::move(err)));
         return;
       }

lldb/test/API/functionalities/memory/find/main.cpp

@@ -1,8 +1,7 @@
 #include <stdio.h>
 #include <stdint.h>
 
-template<size_t T>
-struct [[gnu::packed]] Payload {
+template <size_t T> struct [[gnu::packed]] Payload {
   uint8_t data[T];
 };