Merge pull request #5793 from augusto2112/bind-many-self-params-0

[lldb] Make generic expr eval work with multiple toplevel generic params

Author: augusto2112

lldb/source/Plugins/ExpressionParser/Swift/SwiftASTManipulator.h

@@ -91,6 +91,9 @@ class SwiftASTManipulatorBase {
     swift::VarDecl::Introducer GetVarIntroducer() const;
     bool GetIsCaptureList() const;
     bool IsMetadataPointer() const { return m_name.str().startswith("$τ"); }
+    bool IsOutermostMetadataPointer() const {
+      return m_name.str().startswith("$τ_0_");
+    }
     bool IsSelf() const {
       return !m_name.str().compare("$__lldb_injected_self");
     }

lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionParser.cpp

@@ -503,24 +503,6 @@ lldb::VariableSP SwiftExpressionParser::FindSelfVariable(Block *block) {
   return variable_list_sp->FindVariable(ConstString("self"));
 }
 
-struct BindGenericSelfParamsError : public llvm::ErrorInfo<BindGenericSelfParamsError> {
-  static char ID;
-  std::string msg;
-  bool is_new_dylib;
-
-  BindGenericSelfParamsError() = default;
-
-  void log(llvm::raw_ostream &OS) const override {
-    OS << "Couldn't realize Swift AST type of self. Hint: using `v` to "
-          "directly inspect variables and fields may still work.";
-  }
-  std::error_code convertToErrorCode() const override {
-    return inconvertibleErrorCode();
-  }
-};
-
-char BindGenericSelfParamsError::ID = 0;
-
 static void AddRequiredAliases(Block *block, lldb::StackFrameSP &stack_frame_sp,
                                SwiftASTContextForExpressions &swift_ast_context,
                                SwiftASTManipulator &manipulator,
@@ -1075,9 +1057,10 @@ static llvm::Expected<ParsedExpression> ParseAndImport(
     DiagnosticManager &diagnostic_manager,
     SwiftExpressionParser &swift_expr_parser,
     lldb::StackFrameWP &stack_frame_wp, SymbolContext &sc,
-    ExecutionContextScope &exe_scope,
-    llvm::SmallVector<SwiftASTManipulator::VariableInfo> &local_variables,
-    const EvaluateExpressionOptions &options, bool repl, bool playground) {
+    ExecutionContextScope &exe_scope, 
+    llvm::SmallVectorImpl<SwiftASTManipulator::VariableInfo> &local_variables,
+    const EvaluateExpressionOptions &options,
+    bool repl, bool playground) {
   Log *log = GetLog(LLDBLog::Expressions);
   LLDB_SCOPED_TIMER();
 
@@ -1385,19 +1368,27 @@ RedirectCallFromSinkToTrampolineFunction(llvm::Module &module,
   }
 
   auto *trampoline_func_type = trampoline_func->getFunctionType();
-  auto num_params = trampoline_func_type->getNumParams();
-  // There should be 3 params, the raw pointer, the self type, and the pointer
-  // to metadata
-  if (num_params != 3) {
+  auto trampoline_num_params = trampoline_func_type->getNumParams();
+  // There should be at least 3 params, the raw pointer, the self type, and at
+  // least one pointer to metadata.
+  if (trampoline_num_params < 3) {
     log->Printf(
         "[RedirectCallFromSinkToTrampolineFunction] Could not set the call: "
         "trampoline function has %u parameters",
-        num_params);
+        trampoline_num_params);
     return false;
   }
 
-  llvm::Type *param1 = trampoline_func_type->getParamType(1);
-  llvm::Type *param2 = trampoline_func_type->getParamType(2);
+  auto *sink_func_type = sink_func->getFunctionType();
+  auto sink_num_params = sink_func_type->getNumParams();
+
+  if (trampoline_num_params != sink_num_params) {
+    log->Printf(
+        "[RedirectCallFromSinkToTrampolineFunction] Could not set the call: "
+        "trampoline function has %u parameters but sink has %u parameters.",
+        trampoline_num_params, sink_num_params);
+    return false;
+  }
 
   auto &basic_blocks = lldb_expr_func->getBasicBlockList();
   // The entrypoint function should only have one basic block whith
@@ -1436,18 +1427,22 @@ RedirectCallFromSinkToTrampolineFunction(llvm::Module &module,
     return false;
   }
 
-  if (sink_call->arg_size() != 3) {
+  if (sink_call->arg_size() != sink_num_params) {
     log->Printf(
         "[RedirectCallFromSinkToTrampolineFunction] Could not set the call: "
         "call to sink function has %u arguments.",
         sink_call->arg_size());
     return false;
   }
-  // The sink call should have three parameters, the pointer to lldb_arg, a
-  // pointer to self and a pointer to the trampoline metadata of self.
+
+  // The sink call should have at least three parameters, the pointer to
+  // lldb_arg, a pointer to self and a pointer to the trampoline metadata of
+  // self.
   llvm::Value *lldb_arg_ptr = sink_call->getArgOperand(0);
   llvm::Value *self_load = sink_call->getArgOperand(1);
-  llvm::Value *metadata_load = sink_call->getArgOperand(2);
+  llvm::SmallVector<llvm::Value *> metadata_loads;
+  for (size_t i = 2; i < sink_num_params; ++i)
+    metadata_loads.emplace_back(sink_call->getArgOperand(i));
 
   // Delete the sink since we fished out the values we needed.
   sink_call->eraseFromParent();
@@ -1469,14 +1464,23 @@ RedirectCallFromSinkToTrampolineFunction(llvm::Module &module,
   // new call there.
   llvm::IRBuilder<> builder(&it);
 
+  llvm::Type *lldb_arg_type = trampoline_func_type->getParamType(1);
+  llvm::Type *self_type = trampoline_func_type->getParamType(2);
+
   // Bitcast the operands to the expected types, since they were type-erased
   // in the call to the sink.
-  auto *self_ptr = builder.CreateBitCast(self_opaque_ptr, param1);
-  auto *metadata_ptr = builder.CreateBitCast(metadata_load, param2);
+  auto *self_ptr = builder.CreateBitCast(self_opaque_ptr, lldb_arg_type);
+
+  llvm::SmallVector<llvm::Value *> trampoline_call_params;
+  trampoline_call_params.push_back(lldb_arg_ptr);
+  trampoline_call_params.push_back(self_ptr);
+  for (auto &metadata_load : metadata_loads)
+    trampoline_call_params.push_back(
+        builder.CreateBitCast(metadata_load, self_type));
 
   // Finally, create the call.
   builder.CreateCall(trampoline_func_type, trampoline_func,
-                     {lldb_arg_ptr, self_ptr, metadata_ptr});
+                     trampoline_call_params);
   return true;
 }
 
@@ -1512,7 +1516,6 @@ SwiftExpressionParser::Parse(DiagnosticManager &diagnostic_manager,
 
   if (!parsed_expr) {
     bool retry = false;
-    bool bind_gen_params_error = false;
     handleAllErrors(
         parsed_expr.takeError(),
         [&](const ModuleImportError &MIE) {
@@ -1538,14 +1541,8 @@ SwiftExpressionParser::Parse(DiagnosticManager &diagnostic_manager,
           diagnostic_manager.PutString(eDiagnosticSeverityError,
                                        SE.getMessage());
         },
-        [&](const BindGenericSelfParamsError &E) {
-          diagnostic_manager.PutString(eDiagnosticSeverityError, E.message());
-          bind_gen_params_error = true;
-        },
         [](const PropagatedError &P) {});
 
-    if (bind_gen_params_error) 
-      return ParseResult::retry_no_bind_generic_params;
     // Signal that we want to retry the expression exactly once with a
     // fresh SwiftASTContext initialized with the flags from the
     // current lldb::Module / Swift dylib to avoid header search

lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionSourceCode.cpp

@@ -26,12 +26,96 @@ static const char *GetUserCodeStartMarker() {
 }
 static const char *GetUserCodeEndMarker() { return "\n/*__LLDB_USER_END__*/"; }
 
-static void WrapExpression(lldb_private::Stream &wrapped_stream,
-                           const char *orig_text, bool needs_object_ptr,
-                           bool static_method, bool is_class, bool weak_self,
-                           const EvaluateExpressionOptions &options,
-                           llvm::StringRef os_version,
-                           uint32_t &first_body_line) {
+
+struct CallsAndArgs {
+  std::string lldb_user_expr;
+  std::string lldb_trampoline;
+  std::string lldb_sink;
+  std::string lldb_call;
+};
+
+/// Constructs the signatures for the expression evaluation functions based on
+/// the metadata variables in scope.
+/// For every outermost metadata pointer in scope ($τ_0_0, $τ_0_1, etc), we want
+/// to generate:
+///
+/// - A $__lldb_user_expr signature that takes in that many metadata pointers:
+///
+/// func $__lldb_user_expr<T0, T1, ..., Tn>
+///     (_ $__lldb_arg: UnsafeMutablePointer<(T0, T1, ..., Tn)>)
+///
+/// - A $__lldb_trampoline signature like the above, but that also takes in a
+/// pointer to self:
+///
+/// func $__lldb_trampoline<T0, T1, ..., Tn>
+///      (_ $__lldb_arg: UnsafeMutablePointer<(T0, T1, ..., Tn)>,
+///       _ $__lldb_injected_self: inout $__lldb_context)
+///
+/// - A $__lldb_sink signature that matches the number of parameters of the
+/// trampoline:
+///
+/// func $__lldb_sink(_ $__lldb_arg : UnsafeMutablePointer<Any>,
+///                   _: $__lldb_builtin_ptr_t, // the self variable
+///                   _: $__lldb_builtin_ptr_t, // T0
+///                   _: $__lldb_builtin_ptr_t, // T1
+///                   ...,
+///                   _: $__lldb_builtin_ptr_t) // Tn
+///
+/// - And a matching call to the sink function:
+///
+/// lldb_sink($__lldb_arg, $__lldb_injected_self, $τ_0_0, $τ_0_1, ..., $τ_0_n)
+static CallsAndArgs MakeGenericSignaturesAndCalls(
+    llvm::ArrayRef<SwiftASTManipulator::VariableInfo> local_variables) {
+  llvm::SmallVector<SwiftASTManipulator::VariableInfo> metadata_variables;
+  for (auto &var : local_variables)
+    if (var.IsOutermostMetadataPointer())
+      metadata_variables.push_back(var);
+
+  std::string generic_param_list;
+  llvm::raw_string_ostream generic_param_list_stream(generic_param_list);
+  for (size_t i = 0; i < metadata_variables.size(); ++i)
+    generic_param_list_stream << "T" << i << ",";
+
+  if (!generic_param_list.empty())
+    generic_param_list.pop_back();
+
+  std::string user_expr; 
+  llvm::raw_string_ostream user_expr_stream(user_expr);
+  user_expr_stream << "func $__lldb_user_expr<" << generic_param_list
+                   << ">(_ $__lldb_arg: UnsafeMutablePointer<("
+                   << generic_param_list << ")>)";
+
+
+  std::string trampoline;
+  llvm::raw_string_ostream trampoline_stream(trampoline);
+  trampoline_stream << "func $__lldb_trampoline<" << generic_param_list
+                    << ">(_ $__lldb_arg: UnsafeMutablePointer<("
+                    << generic_param_list
+                    << ")>, _ $__lldb_injected_self: inout $__lldb_context)";
+
+  std::string sink;
+  std::string call;
+  llvm::raw_string_ostream sink_stream(sink);
+  llvm::raw_string_ostream call_stream(call);
+  sink_stream << "func $__lldb_sink(_ $__lldb_arg : "
+                 "UnsafeMutablePointer<Any>, _: $__lldb_builtin_ptr_t";
+  call_stream << "$__lldb_sink($__lldb_arg, $__lldb_injected_self";
+  for (auto &var : metadata_variables) {
+    sink_stream << ", _: $__lldb_builtin_ptr_t";
+    call_stream << ", " << var.GetName().str();
+  }
+  sink_stream << ")";
+  call_stream << ")";
+
+  return {user_expr, trampoline, sink, call};
+}
+
+void WrapExpression(
+    lldb_private::Stream &wrapped_stream, const char *orig_text,
+    bool needs_object_ptr, bool static_method, bool is_class, bool weak_self,
+    const EvaluateExpressionOptions &options, llvm::StringRef os_version,
+    uint32_t &first_body_line,
+    llvm::ArrayRef<SwiftASTManipulator::VariableInfo> local_variables) {
   first_body_line = 0; // set to invalid
   // TODO make the extension private so we're not polluting the class
   static unsigned int counter = 0;
@@ -142,7 +226,8 @@ do {
 }
 )",
                            GetUserCodeStartMarker(), text,
-                           GetUserCodeEndMarker(), SwiftASTManipulator::GetErrorName());
+                           GetUserCodeEndMarker(),
+                           SwiftASTManipulator::GetErrorName());
 
   if (needs_object_ptr || static_method) {
     const char *func_decorator = "";
@@ -201,41 +286,41 @@ do {
       // FIXME: the current approach names the generic parameter "T", use the
       // user's name for the generic parameter, so they can refer to it in
       // their expression.
+      auto c = MakeGenericSignaturesAndCalls(local_variables);
       wrapped_stream.Printf(
           R"(
 extension %s$__lldb_context {
   @LLDBDebuggerFunction %s
-  %s func $__lldb_user_expr_%u<T>(_ $__lldb_arg: UnsafeMutablePointer<(T)>) {
+  %s %s {
     %s
   }
 }
 
 @LLDBDebuggerFunction %s
-func $__lldb_trampoline<T>(_ $__lldb_arg: UnsafeMutablePointer<(T)>,
-                             _ $__lldb_injected_self: inout $__lldb_context) {
+%s {
   do {
-    $__lldb_injected_self.$__lldb_user_expr_%u(
+    $__lldb_injected_self.$__lldb_user_expr(
       $__lldb_arg
     )
   }
 }
 
 
 @LLDBDebuggerFunction %s
-func $__lldb_sink(_ $__lldb_arg : UnsafeMutablePointer<Any>,
-                       _: $__lldb_builtin_ptr_t,
-                       _: $__lldb_builtin_ptr_t) {
+%s {
 }
 
 
 @LLDBDebuggerFunction %s
 func $__lldb_expr(_ $__lldb_arg : UnsafeMutablePointer<Any>) {
-  $__lldb_sink($__lldb_arg, $__lldb_injected_self, $τ_0_0)
+%s
 }
 )",
           optional_extension, availability.c_str(), func_decorator,
-          current_counter, wrapped_expr_text.GetData(), availability.c_str(),
-          current_counter, availability.c_str(), availability.c_str());
+          c.lldb_user_expr.c_str(), wrapped_expr_text.GetData(),
+          availability.c_str(), c.lldb_trampoline.c_str(),
+          availability.c_str(), c.lldb_sink.c_str(), availability.c_str(),
+          c.lldb_call.c_str());
 
     } else {
       wrapped_stream.Printf(R"(
@@ -270,6 +355,7 @@ func $__lldb_expr(_ $__lldb_arg : UnsafeMutablePointer<Any>) {
     first_body_line = 4;
   }
 }
+
 /// Format the OS name the way that Swift availability attributes do.
 static llvm::StringRef getAvailabilityName(const llvm::Triple &triple) {
     swift::LangOptions lang_options;
@@ -285,16 +371,11 @@ uint32_t SwiftExpressionSourceCode::GetNumBodyLines() {
 }
 
 bool SwiftExpressionSourceCode::GetText(
-               std::string &text, 
-               lldb::LanguageType wrapping_language,
-               bool needs_object_ptr,
-               bool static_method,
-               bool is_class,
-               bool weak_self,
-               const EvaluateExpressionOptions &options,
-               ExecutionContext &exe_ctx,
-               uint32_t &first_body_line) const
-  {
+    std::string &text, lldb::LanguageType wrapping_language,
+    bool needs_object_ptr, bool static_method, bool is_class, bool weak_self,
+    const EvaluateExpressionOptions &options, ExecutionContext &exe_ctx,
+    uint32_t &first_body_line,
+    llvm::ArrayRef<SwiftASTManipulator::VariableInfo> local_variables) const {
   Target *target = exe_ctx.GetTargetPtr();
 
 
@@ -364,7 +445,7 @@ bool SwiftExpressionSourceCode::GetText(
     std::string full_body = m_prefix + m_body;
     WrapExpression(wrap_stream, full_body.c_str(), needs_object_ptr,
                    static_method, is_class, weak_self, localOptions,
-                   os_vers.str(), first_body_line);
+                   os_vers.str(), first_body_line, local_variables);
 
     text = wrap_stream.GetString().str();
   } else {

lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionSourceCode.h

@@ -9,6 +9,7 @@
 #ifndef liblldb_SwiftExpressionSourceCode_h
 #define liblldb_SwiftExpressionSourceCode_h
 
+#include "SwiftASTManipulator.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Expression/ExpressionSourceCode.h"
 #include "lldb/lldb-enumerations.h"
@@ -36,15 +37,12 @@ class SwiftExpressionSourceCode : public ExpressionSourceCode {
 
   uint32_t GetNumBodyLines();
 
-  bool GetText(std::string &text, 
-               lldb::LanguageType wrapping_language,
-               bool needs_object_ptr,
-               bool static_method,
-               bool is_class,
-               bool weak_self,
-               const EvaluateExpressionOptions &options,
-               ExecutionContext &exe_ctx,
-               uint32_t &first_body_line) const;
+  bool GetText(
+      std::string &text, lldb::LanguageType wrapping_language,
+      bool needs_object_ptr, bool static_method, bool is_class, bool weak_self,
+      const EvaluateExpressionOptions &options, ExecutionContext &exe_ctx,
+      uint32_t &first_body_line,
+      llvm::ArrayRef<SwiftASTManipulator::VariableInfo> local_variables) const;
 
 private:
   SwiftExpressionSourceCode(const char *name, const char *prefix, const char *body,