Refactoring std::function formatter to move core functionality into CPPLanguageRuntime

[shafik]

Summary

Moving the core functionality of std::function formatter into CPPLanguageRuntime in preparation for future changes to allow us to step into the wrapped callable of std::function.

This will prevent code duplication since both functionalities require the same core pieces of information. This refactor also improves the readability of the existing functionality.

[jingham]

Since the runtime has to use the results of the introspection that the formatter is based on, it seems appropriate to put it there. This seems like a fine way to do it.

[shafik]

Removing change that was meant for the next PR

lldb/trunk/include/lldb/Target/CPPLanguageRuntime.h

 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class CPPLanguageRuntime : public LanguageRuntime {
 public:
+  enum class LibCppStdFunctionCallableCase {
+    Lambda = 0,
+    CallableObject,
+    FreeOrMemberFunction,
+    Invalid
+  };
+
+  struct LibCppStdFunctionCallableInfo {
+    Symbol callable_symbol;
+    Address callable_address;
+    LineEntry callable_line_entry;
+    lldb::addr_t member__f_pointer_value = 0u;
+    LibCppStdFunctionCallableCase callable_case =
+        LibCppStdFunctionCallableCase::Invalid;
+  };
+
+  LibCppStdFunctionCallableInfo
+  FindLibCppStdFunctionCallableInfo(lldb::ValueObjectSP &valobj_sp);
+
   ~CPPLanguageRuntime() override;
 
   lldb::LanguageType GetLanguageType() const override {
     return lldb::eLanguageTypeC_plus_plus;
   }
 
   virtual bool IsVTableName(const char *name) = 0;
 

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxx.cpp

 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/DataFormatters/VectorIterator.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/CPPLanguageRuntime.h"
 #include "lldb/Target/ProcessStructReader.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 

 bool lldb_private::formatters::LibcxxFunctionSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
 
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
 
   if (!valobj_sp)
     return false;
 
-  // Member __f_ has type __base*, the contents of which will hold:
-  // 1) a vtable entry which may hold type information needed to discover the
-  //    lambda being called
-  // 2) possibly hold a pointer to the callable object
-  // e.g.
-  //
-  // (lldb) frame var -R  f_display
-  // (std::__1::function<void (int)>) f_display = {
-  //  __buf_ = {
-  //  …
-  // }
-  //  __f_ = 0x00007ffeefbffa00
-  // }
-  // (lldb) memory read -fA 0x00007ffeefbffa00
-  // 0x7ffeefbffa00: ... `vtable for std::__1::__function::__func<void (*) ...
-  // 0x7ffeefbffa08: ... `print_num(int) at std_function_cppreference_exam ...
-  //
-  // We will be handling five cases below, std::function is wrapping:
-  //
-  // 1) a lambda we know at compile time. We will obtain the name of the lambda
-  //    from the first template pameter from __func's vtable. We will look up
-  //    the lambda's operator()() and obtain the line table entry.
-  // 2) a lambda we know at runtime. A pointer to the lambdas __invoke method
-  //    will be stored after the vtable. We will obtain the lambdas name from
-  //    this entry and lookup operator()() and obtain the line table entry.
-  // 3) a callable object via operator()(). We will obtain the name of the
-  //    object from the first template parameter from __func's vtable. We will
-  //    look up the objectc operator()() and obtain the line table entry.
-  // 4) a member function. A pointer to the function will stored after the
-  //    we will obtain the name from this pointer.
-  // 5) a free function. A pointer to the function will stored after the vtable
-  //    we will obtain the name from this pointer.
-  ValueObjectSP member__f_(
-      valobj_sp->GetChildMemberWithName(ConstString("__f_"), true));
-  lldb::addr_t member__f_pointer_value = member__f_->GetValueAsUnsigned(0);
-
   ExecutionContext exe_ctx(valobj_sp->GetExecutionContextRef());
   Process *process = exe_ctx.GetProcessPtr();
 
   if (process == nullptr)
     return false;
 
-  uint32_t address_size = process->GetAddressByteSize();
-  Status status;
-
-  // First item pointed to by __f_ should be the pointer to the vtable for
-  // a __base object.
-  lldb::addr_t vtable_address =
-      process->ReadPointerFromMemory(member__f_pointer_value, status);
-
-  if (status.Fail())
-    return false;
-
-  bool found_wrapped_function = false;
-
-  // Using scoped exit so we can use early return and still execute the default
-  // action in case we don't find the wrapper function. Otherwise we can't use
-  // early exit without duplicating code.
-  auto default_print_on_exit = llvm::make_scope_exit(
-      [&found_wrapped_function, &stream, &member__f_pointer_value]() {
-        if (!found_wrapped_function)
-          stream.Printf(" __f_ = %" PRIu64, member__f_pointer_value);
-      });
-
-  lldb::addr_t address_after_vtable = member__f_pointer_value + address_size;
-  // As commened above we may not have a function pointer but if we do we will
-  // need it.
-  lldb::addr_t possible_function_address =
-      process->ReadPointerFromMemory(address_after_vtable, status);
-
-  if (status.Fail())
-    return false;
-
-  Target &target = process->GetTarget();
+  CPPLanguageRuntime *cpp_runtime = process->GetCPPLanguageRuntime();
 
-  if (target.GetSectionLoadList().IsEmpty())
+  if (!cpp_runtime)
     return false;
 
-  Address vtable_addr_resolved;
-  SymbolContext sc;
-  Symbol *symbol;
+  CPPLanguageRuntime::LibCppStdFunctionCallableInfo callable_info =
+      cpp_runtime->FindLibCppStdFunctionCallableInfo(valobj_sp);
 
-  if (!target.GetSectionLoadList().ResolveLoadAddress(vtable_address,
-                                                      vtable_addr_resolved))
+  switch (callable_info.callable_case) {
+  case CPPLanguageRuntime::LibCppStdFunctionCallableCase::Invalid:
+    stream.Printf(" __f_ = %" PRIu64, callable_info.member__f_pointer_value);
     return false;
-
-  target.GetImages().ResolveSymbolContextForAddress(
-      vtable_addr_resolved, eSymbolContextEverything, sc);
-  symbol = sc.symbol;
-
-  if (symbol == NULL)
-    return false;
-
-  llvm::StringRef vtable_name(symbol->GetName().GetCString());
-  bool found_expected_start_string =
-      vtable_name.startswith("vtable for std::__1::__function::__func<");
-
-  if (!found_expected_start_string)
-    return false;
-
-  // Given case 1 or 3 we have a vtable name, we are want to extract the first
-  // template parameter
-  //
-  //  ... __func<main::$_0, std::__1::allocator<main::$_0> ...
-  //             ^^^^^^^^^
-  //
-  // We do this by find the first < and , and extracting in between.
-  //
-  // This covers the case of the lambda known at compile time.
-  //
-  size_t first_open_angle_bracket = vtable_name.find('<') + 1;
-  size_t first_comma = vtable_name.find_first_of(',');
-
-  llvm::StringRef first_template_parameter =
-      vtable_name.slice(first_open_angle_bracket, first_comma);
-
-  Address function_address_resolved;
-
-  // Setup for cases 2, 4 and 5 we have a pointer to a function after the
-  // vtable. We will use a process of elimination to drop through each case
-  // and obtain the data we need.
-  if (target.GetSectionLoadList().ResolveLoadAddress(
-          possible_function_address, function_address_resolved)) {
-    target.GetImages().ResolveSymbolContextForAddress(
-        function_address_resolved, eSymbolContextEverything, sc);
-    symbol = sc.symbol;
-  }
-
-  auto get_name = [&first_template_parameter, &symbol]() {
-    // Given case 1:
-    //
-    //    main::$_0
-    //
-    // we want to append ::operator()()
-    if (first_template_parameter.contains("$_"))
-      return llvm::Regex::escape(first_template_parameter.str()) +
-             R"(::operator\(\)\(.*\))";
-
-    if (symbol != NULL &&
-        symbol->GetName().GetStringRef().contains("__invoke")) {
-
-      llvm::StringRef symbol_name = symbol->GetName().GetStringRef();
-      size_t pos2 = symbol_name.find_last_of(':');
-
-      // Given case 2:
-      //
-      //    main::$_1::__invoke(...)
-      //
-      // We want to slice off __invoke(...) and append operator()()
-      std::string lambda_operator =
-          llvm::Regex::escape(symbol_name.slice(0, pos2 + 1).str()) +
-          R"(operator\(\)\(.*\))";
-
-      return lambda_operator;
-    }
-
-    // Case 3
-    return first_template_parameter.str() + R"(::operator\(\)\(.*\))";
-    ;
-  };
-
-  std::string func_to_match = get_name();
-
-  SymbolContextList scl;
-
-  target.GetImages().FindFunctions(RegularExpression{func_to_match}, true, true,
-                                   true, scl);
-
-  // Case 1,2 or 3
-  if (scl.GetSize() >= 1) {
-    SymbolContext sc2 = scl[0];
-
-    AddressRange range;
-    sc2.GetAddressRange(eSymbolContextEverything, 0, false, range);
-
-    Address address = range.GetBaseAddress();
-
-    Address addr;
-    if (target.ResolveLoadAddress(address.GetCallableLoadAddress(&target),
-                                  addr)) {
-      LineEntry line_entry;
-      addr.CalculateSymbolContextLineEntry(line_entry);
-
-      found_wrapped_function = true;
-      if (first_template_parameter.contains("$_") ||
-          (symbol != NULL &&
-           symbol->GetName().GetStringRef().contains("__invoke"))) {
-        // Case 1 and 2
-        stream.Printf(" Lambda in File %s at Line %u",
-                      line_entry.file.GetFilename().GetCString(),
-                      line_entry.line);
-      } else {
-        // Case 3
-        stream.Printf(" Function in File %s at Line %u",
-                      line_entry.file.GetFilename().GetCString(),
-                      line_entry.line);
-      }
-
-      return true;
-    }
+    break;
+  case CPPLanguageRuntime::LibCppStdFunctionCallableCase::Lambda:
+    stream.Printf(
+        " Lambda in File %s at Line %u",
+        callable_info.callable_line_entry.file.GetFilename().GetCString(),
+        callable_info.callable_line_entry.line);
+    break;
+  case CPPLanguageRuntime::LibCppStdFunctionCallableCase::CallableObject:
+    stream.Printf(
+        " Function in File %s at Line %u",
+        callable_info.callable_line_entry.file.GetFilename().GetCString(),
+        callable_info.callable_line_entry.line);
+    break;
+  case CPPLanguageRuntime::LibCppStdFunctionCallableCase::FreeOrMemberFunction:
+    stream.Printf(" Function = %s ",
+                  callable_info.callable_symbol.GetName().GetCString());
+    break;
   }
 
-  // Case 4 or 5
-  if (!symbol->GetName().GetStringRef().startswith("vtable for")) {
-    found_wrapped_function = true;
-    stream.Printf(" Function = %s ", symbol->GetName().GetCString());
-    return true;
-  }
 
-  return false;
-}
-
 bool lldb_private::formatters::LibcxxSmartPointerSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
   ValueObjectSP ptr_sp(
       valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true));
   ValueObjectSP count_sp(valobj_sp->GetChildAtNamePath(

lldb/trunk/source/Target/CPPLanguageRuntime.cpp

 //===-- CPPLanguageRuntime.cpp
 //-------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/CPPLanguageRuntime.h"
 
 #include <string.h>
 
 #include "llvm/ADT/StringRef.h"
 
+#include "lldb/API/SBValue.h"
+#include "lldb/Symbol/Block.h"
+#include "lldb/Symbol/VariableList.h"
+
+#include "lldb/API/SBFrame.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/UniqueCStringMap.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/SectionLoadList.h"
+#include "lldb/Target/StackFrame.h"
+#include "lldb/Target/ThreadPlanRunToAddress.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 CPPLanguageRuntime::~CPPLanguageRuntime() {}
 
 CPPLanguageRuntime::CPPLanguageRuntime(Process *process)
     : LanguageRuntime(process) {}
 
 bool CPPLanguageRuntime::GetObjectDescription(Stream &str,
                                               ValueObject &object) {
   // C++ has no generic way to do this.
   return false;
 }
 
 bool CPPLanguageRuntime::GetObjectDescription(
     Stream &str, Value &value, ExecutionContextScope *exe_scope) {
   // C++ has no generic way to do this.
   return false;
 }
+
+CPPLanguageRuntime::LibCppStdFunctionCallableInfo
+CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo(
+    lldb::ValueObjectSP &valobj_sp) {
+  LibCppStdFunctionCallableInfo optional_info;
+
+  if (!valobj_sp)
+    return optional_info;
+
+  // Member __f_ has type __base*, the contents of which will hold:
+  // 1) a vtable entry which may hold type information needed to discover the
+  //    lambda being called
+  // 2) possibly hold a pointer to the callable object
+  // e.g.
+  //
+  // (lldb) frame var -R  f_display
+  // (std::__1::function<void (int)>) f_display = {
+  //  __buf_ = {
+  //  …
+  // }
+  //  __f_ = 0x00007ffeefbffa00
+  // }
+  // (lldb) memory read -fA 0x00007ffeefbffa00
+  // 0x7ffeefbffa00: ... `vtable for std::__1::__function::__func<void (*) ...
+  // 0x7ffeefbffa08: ... `print_num(int) at std_function_cppreference_exam ...
+  //
+  // We will be handling five cases below, std::function is wrapping:
+  //
+  // 1) a lambda we know at compile time. We will obtain the name of the lambda
+  //    from the first template pameter from __func's vtable. We will look up
+  //    the lambda's operator()() and obtain the line table entry.
+  // 2) a lambda we know at runtime. A pointer to the lambdas __invoke method
+  //    will be stored after the vtable. We will obtain the lambdas name from
+  //    this entry and lookup operator()() and obtain the line table entry.
+  // 3) a callable object via operator()(). We will obtain the name of the
+  //    object from the first template parameter from __func's vtable. We will
+  //    look up the objectc operator()() and obtain the line table entry.
+  // 4) a member function. A pointer to the function will stored after the
+  //    we will obtain the name from this pointer.
+  // 5) a free function. A pointer to the function will stored after the vtable
+  //    we will obtain the name from this pointer.
+  ValueObjectSP member__f_(
+      valobj_sp->GetChildMemberWithName(ConstString("__f_"), true));
+  lldb::addr_t member__f_pointer_value = member__f_->GetValueAsUnsigned(0);
+
+  optional_info.member__f_pointer_value = member__f_pointer_value;
+
+  ExecutionContext exe_ctx(valobj_sp->GetExecutionContextRef());
+  Process *process = exe_ctx.GetProcessPtr();
+
+  if (process == nullptr)
+    return optional_info;
+
+  uint32_t address_size = process->GetAddressByteSize();
+  Status status;
+
+  // First item pointed to by __f_ should be the pointer to the vtable for
+  // a __base object.
+  lldb::addr_t vtable_address =
+      process->ReadPointerFromMemory(member__f_pointer_value, status);
+
+  if (status.Fail())
+    return optional_info;
+
+  lldb::addr_t address_after_vtable = member__f_pointer_value + address_size;
+  // As commened above we may not have a function pointer but if we do we will
+  // need it.
+  lldb::addr_t possible_function_address =
+      process->ReadPointerFromMemory(address_after_vtable, status);
+
+  if (status.Fail())
+    return optional_info;
+
+  Target &target = process->GetTarget();
+
+  if (target.GetSectionLoadList().IsEmpty())
+    return optional_info;
+
+  Address vtable_addr_resolved;
+  SymbolContext sc;
+  Symbol *symbol;
+
+  if (!target.GetSectionLoadList().ResolveLoadAddress(vtable_address,
+                                                      vtable_addr_resolved))
+    return optional_info;
+
+  target.GetImages().ResolveSymbolContextForAddress(
+      vtable_addr_resolved, eSymbolContextEverything, sc);
+  symbol = sc.symbol;
+
+  if (symbol == nullptr)
+    return optional_info;
+
+  llvm::StringRef vtable_name(symbol->GetName().GetCString());
+  bool found_expected_start_string =
+      vtable_name.startswith("vtable for std::__1::__function::__func<");
+
+  if (!found_expected_start_string)
+    return optional_info;
+
+  // Given case 1 or 3 we have a vtable name, we are want to extract the first
+  // template parameter
+  //
+  //  ... __func<main::$_0, std::__1::allocator<main::$_0> ...
+  //             ^^^^^^^^^
+  //
+  // We do this by find the first < and , and extracting in between.
+  //
+  // This covers the case of the lambda known at compile time.
+  //
+  size_t first_open_angle_bracket = vtable_name.find('<') + 1;
+  size_t first_comma = vtable_name.find_first_of(',');
+
+  llvm::StringRef first_template_parameter =
+      vtable_name.slice(first_open_angle_bracket, first_comma);
+
+  Address function_address_resolved;
+
+  // Setup for cases 2, 4 and 5 we have a pointer to a function after the
+  // vtable. We will use a process of elimination to drop through each case
+  // and obtain the data we need.
+  if (target.GetSectionLoadList().ResolveLoadAddress(
+          possible_function_address, function_address_resolved)) {
+    target.GetImages().ResolveSymbolContextForAddress(
+        function_address_resolved, eSymbolContextEverything, sc);
+    symbol = sc.symbol;
+  }
+
+  auto get_name = [&first_template_parameter, &symbol]() {
+    // Given case 1:
+    //
+    //    main::$_0
+    //
+    // we want to append ::operator()()
+    if (first_template_parameter.contains("$_"))
+      return llvm::Regex::escape(first_template_parameter.str()) +
+             R"(::operator\(\)\(.*\))";
+
+    if (symbol != NULL &&
+        symbol->GetName().GetStringRef().contains("__invoke")) {
+
+      llvm::StringRef symbol_name = symbol->GetName().GetStringRef();
+      size_t pos2 = symbol_name.find_last_of(':');
+
+      // Given case 2:
+      //
+      //    main::$_1::__invoke(...)
+      //
+      // We want to slice off __invoke(...) and append operator()()
+      std::string lambda_operator =
+          llvm::Regex::escape(symbol_name.slice(0, pos2 + 1).str()) +
+          R"(operator\(\)\(.*\))";
+
+      return lambda_operator;
+    }
+
+    // Case 3
+    return first_template_parameter.str() + R"(::operator\(\)\(.*\))";
+    ;
+  };
+
+  std::string func_to_match = get_name();
+
+  SymbolContextList scl;
+
+  target.GetImages().FindFunctions(RegularExpression{func_to_match}, true, true,
+                                   true, scl);
+
+  // Case 1,2 or 3
+  if (scl.GetSize() >= 1) {
+    SymbolContext sc2 = scl[0];
+
+    AddressRange range;
+    sc2.GetAddressRange(eSymbolContextEverything, 0, false, range);
+
+    Address address = range.GetBaseAddress();
+
+    Address addr;
+    if (target.ResolveLoadAddress(address.GetCallableLoadAddress(&target),
+                                  addr)) {
+      LineEntry line_entry;
+      addr.CalculateSymbolContextLineEntry(line_entry);
+
+      if (first_template_parameter.contains("$_") ||
+          (symbol != nullptr &&
+           symbol->GetName().GetStringRef().contains("__invoke"))) {
+        // Case 1 and 2
+        optional_info.callable_case = LibCppStdFunctionCallableCase::Lambda;
+      } else {
+        // Case 3
+        optional_info.callable_case =
+            LibCppStdFunctionCallableCase::CallableObject;
+      }
+
+      optional_info.callable_symbol = *symbol;
+      optional_info.callable_line_entry = line_entry;
+      optional_info.callable_address = addr;
+      return optional_info;
+    }
+  }
+
+  // Case 4 or 5
+  if (!symbol->GetName().GetStringRef().startswith("vtable for")) {
+    optional_info.callable_case =
+        LibCppStdFunctionCallableCase::FreeOrMemberFunction;
+    optional_info.callable_address = function_address_resolved;
+    optional_info.callable_symbol = *symbol;
+
+    return optional_info;
+  }
+
+  return optional_info;
+}