Adapt the ObjC stepping algorithm to deal with "selector-stubs" in clang.

Clang is adding a feature to ObjC code generation, where instead of calling
objc_msgSend directly with an object & selector, it generates a stub that
gets passed only the object and the stub figures out the selector.

This patch adds support for following that dispatch method into the implementation
function.

(cherry picked from commit 833882b)

Author: jimingham

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

@@ -1567,7 +1567,7 @@ AppleObjCRuntimeV2::DynamicClassInfoExtractor::GetClassInfoUtilityFunctionImpl(
   if (!utility_fn_or_error) {
     LLDB_LOG_ERROR(
         log, utility_fn_or_error.takeError(),
-        "Failed to get utility function for implementation lookup: {0}");
+        "Failed to get utility function for dynamic info extractor: {0}");
     return {};
   }
 
@@ -1697,7 +1697,7 @@ AppleObjCRuntimeV2::SharedCacheClassInfoExtractor::
   if (!utility_fn_or_error) {
     LLDB_LOG_ERROR(
         log, utility_fn_or_error.takeError(),
-        "Failed to get utility function for implementation lookup: {0}");
+        "Failed to get utility function for shared class info extractor: {0}");
     return nullptr;
   }
 

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

@@ -38,11 +38,11 @@ class AppleObjCTrampolineHandler {
   public:
     enum FixUpState { eFixUpNone, eFixUpFixed, eFixUpToFix };
 
-    const char *name;
-    bool stret_return;
-    bool is_super;
-    bool is_super2;
-    FixUpState fixedup;
+    const char *name = nullptr;
+    bool stret_return = false;
+    bool is_super = false;
+    bool is_super2 = false;
+    FixUpState fixedup = eFixUpNone;
   };
 
   lldb::addr_t SetupDispatchFunction(Thread &thread,
@@ -52,9 +52,19 @@ class AppleObjCTrampolineHandler {
                                                   const DispatchFunction &)>);
 
 private:
+  /// These hold the code for the function that finds the implementation of
+  /// an ObjC message send given the class & selector and the kind of dispatch.
+  /// There are two variants depending on whether the platform uses a separate
+  /// _stret passing convention (e.g. Intel) or not (e.g. ARM).  The difference
+  /// is only at the very end of the function, so the code is broken into the
+  /// common prefix and the suffix, which get composed appropriately before
+  /// the function gets compiled.
+  /// \{
   static const char *g_lookup_implementation_function_name;
+  static const char *g_lookup_implementation_function_common_code;
   static const char *g_lookup_implementation_with_stret_function_code;
   static const char *g_lookup_implementation_no_stret_function_code;
+  /// \}
 
   class AppleObjCVTables {
   public:
@@ -144,7 +154,7 @@ class AppleObjCTrampolineHandler {
   MsgsendMap m_opt_dispatch_map;
   lldb::ProcessWP m_process_wp;
   lldb::ModuleSP m_objc_module_sp;
-  const char *m_lookup_implementation_function_code;
+  std::string m_lookup_implementation_function_code;
   std::unique_ptr<UtilityFunction> m_impl_code;
   std::mutex m_impl_function_mutex;
   lldb::addr_t m_impl_fn_addr;

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h

@@ -32,13 +32,15 @@ using namespace lldb_private;
 AppleThreadPlanStepThroughObjCTrampoline::
     AppleThreadPlanStepThroughObjCTrampoline(
         Thread &thread, AppleObjCTrampolineHandler &trampoline_handler,
-        ValueList &input_values, lldb::addr_t isa_addr, lldb::addr_t sel_addr)
+        ValueList &input_values, lldb::addr_t isa_addr, lldb::addr_t sel_addr,
+        lldb::addr_t sel_str_addr, llvm::StringRef sel_str)
     : ThreadPlan(ThreadPlan::eKindGeneric,
                  "MacOSX Step through ObjC Trampoline", thread, eVoteNoOpinion,
                  eVoteNoOpinion),
       m_trampoline_handler(trampoline_handler),
       m_args_addr(LLDB_INVALID_ADDRESS), m_input_values(input_values),
-      m_isa_addr(isa_addr), m_sel_addr(sel_addr), m_impl_function(nullptr) {}
+      m_isa_addr(isa_addr), m_sel_addr(sel_addr), m_impl_function(nullptr),
+      m_sel_str_addr(sel_str_addr), m_sel_str(sel_str) {}
 
 // Destructor
 AppleThreadPlanStepThroughObjCTrampoline::
@@ -126,8 +128,10 @@ bool AppleThreadPlanStepThroughObjCTrampoline::ShouldStop(Event *event_ptr) {
     }
   }
 
-  // Second stage, if all went well with the function calling, then fetch the
-  // target address, and queue up a "run to that address" plan.
+  // Second stage, if all went well with the function calling,  get the
+  // implementation function address, and queue up a "run to that address" plan.
+  Log *log = GetLog(LLDBLog::Step);
+
   if (!m_run_to_sp) {
     Value target_addr_value;
     ExecutionContext exc_ctx;
@@ -142,7 +146,6 @@ bool AppleThreadPlanStepThroughObjCTrampoline::ShouldStop(Event *event_ptr) {
     }
     Address target_so_addr;
     target_so_addr.SetOpcodeLoadAddress(target_addr, exc_ctx.GetTargetPtr());
-    Log *log = GetLog(LLDBLog::Step);
     if (target_addr == 0) {
       LLDB_LOGF(log, "Got target implementation of 0x0, stopping.");
       SetPlanComplete();
@@ -174,13 +177,25 @@ bool AppleThreadPlanStepThroughObjCTrampoline::ShouldStop(Event *event_ptr) {
     ObjCLanguageRuntime *objc_runtime =
         ObjCLanguageRuntime::Get(*GetThread().GetProcess());
     assert(objc_runtime != nullptr);
-    objc_runtime->AddToMethodCache(m_isa_addr, m_sel_addr, target_addr);
-    LLDB_LOGF(log,
-              "Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64
-              "} = addr=0x%" PRIx64 " to cache.",
-              m_isa_addr, m_sel_addr, target_addr);
-
-    // Extract the target address from the value:
+    if (m_sel_str_addr != LLDB_INVALID_ADDRESS) {
+      // Cache the string -> implementation and free the string in the target.
+      Status dealloc_error =
+          GetThread().GetProcess()->DeallocateMemory(m_sel_str_addr);
+      // For now just log this:
+      if (dealloc_error.Fail())
+        LLDB_LOG(log, "Failed to deallocate the sel str at {0} - error: {1}",
+                 m_sel_str_addr, dealloc_error);
+      objc_runtime->AddToMethodCache(m_isa_addr, m_sel_str, target_addr);
+      LLDB_LOG(log,
+               "Adding \\{isa-addr={0}, sel-addr={1}\\} = addr={2} to cache.",
+               m_isa_addr, m_sel_str, target_addr);
+    } else {
+      objc_runtime->AddToMethodCache(m_isa_addr, m_sel_addr, target_addr);
+      LLDB_LOGF(log,
+                "Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64
+                "} = addr=0x%" PRIx64 " to cache.",
+                m_isa_addr, m_sel_addr, target_addr);
+    }
 
     m_run_to_sp = std::make_shared<ThreadPlanRunToAddress>(
         GetThread(), target_so_addr, false);

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp

@@ -24,7 +24,8 @@ class AppleThreadPlanStepThroughObjCTrampoline : public ThreadPlan {
 public:
   AppleThreadPlanStepThroughObjCTrampoline(
       Thread &thread, AppleObjCTrampolineHandler &trampoline_handler,
-      ValueList &values, lldb::addr_t isa_addr, lldb::addr_t sel_addr);
+      ValueList &values, lldb::addr_t isa_addr, lldb::addr_t sel_addr,
+      lldb::addr_t sel_str_addr, llvm::StringRef sel_str);
 
   ~AppleThreadPlanStepThroughObjCTrampoline() override;
 
@@ -70,6 +71,13 @@ class AppleThreadPlanStepThroughObjCTrampoline : public ThreadPlan {
   FunctionCaller *m_impl_function; /// This is a pointer to a impl function that
                                    /// is owned by the client that pushes this
                                    /// plan.
+  lldb::addr_t m_sel_str_addr; /// If this is not LLDB_INVALID_ADDRESS then it
+                               /// is the address we wrote the selector string
+                               /// to.  We need to deallocate it when the
+                               /// function call is done.
+  std::string m_sel_str;       /// This is the string we wrote to memory - we
+                               /// use it for caching, but only if
+                               /// m_sel_str_addr is non-null.
 };
 
 class AppleThreadPlanStepThroughDirectDispatch: public ThreadPlanStepOut {

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.h

@@ -37,7 +37,7 @@ char ObjCLanguageRuntime::ID = 0;
 ObjCLanguageRuntime::~ObjCLanguageRuntime() = default;
 
 ObjCLanguageRuntime::ObjCLanguageRuntime(Process *process)
-    : LanguageRuntime(process), m_impl_cache(),
+    : LanguageRuntime(process), m_impl_cache(), m_impl_str_cache(),
       m_has_new_literals_and_indexing(eLazyBoolCalculate),
       m_isa_to_descriptor(), m_hash_to_isa_map(), m_type_size_cache(),
       m_isa_to_descriptor_stop_id(UINT32_MAX), m_complete_class_cache(),
@@ -75,6 +75,18 @@ void ObjCLanguageRuntime::AddToMethodCache(lldb::addr_t class_addr,
       ClassAndSel(class_addr, selector), impl_addr));
 }
 
+void ObjCLanguageRuntime::AddToMethodCache(lldb::addr_t class_addr,
+                                           llvm::StringRef sel_str,
+                                           lldb::addr_t impl_addr) {
+  Log *log = GetLog(LLDBLog::Step);
+
+  LLDB_LOG(log, "Caching: class {0} selector {1} implementation {2}.",
+           class_addr, sel_str, impl_addr);
+
+  m_impl_str_cache.insert(std::pair<ClassAndSelStr, lldb::addr_t>(
+      ClassAndSelStr(class_addr, sel_str), impl_addr));
+}
+
 lldb::addr_t ObjCLanguageRuntime::LookupInMethodCache(lldb::addr_t class_addr,
                                                       lldb::addr_t selector) {
   MsgImplMap::iterator pos, end = m_impl_cache.end();
@@ -84,6 +96,15 @@ lldb::addr_t ObjCLanguageRuntime::LookupInMethodCache(lldb::addr_t class_addr,
   return LLDB_INVALID_ADDRESS;
 }
 
+lldb::addr_t ObjCLanguageRuntime::LookupInMethodCache(lldb::addr_t class_addr,
+                                                      llvm::StringRef sel_str) {
+  MsgImplStrMap::iterator pos, end = m_impl_str_cache.end();
+  pos = m_impl_str_cache.find(ClassAndSelStr(class_addr, sel_str));
+  if (pos != end)
+    return (*pos).second;
+  return LLDB_INVALID_ADDRESS;
+}
+
 lldb::TypeSP
 ObjCLanguageRuntime::LookupInCompleteClassCache(ConstString &name) {
   CompleteClassMap::iterator complete_class_iter =

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp

@@ -22,6 +22,7 @@
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/LanguageRuntime.h"
+#include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 
 class CommandObjectObjC_ClassTable_Dump;
@@ -242,11 +243,19 @@ class ObjCLanguageRuntime : public LanguageRuntime {
 
   virtual bool HasReadObjCLibrary() = 0;
 
+  // These two methods actually use different caches.  The only time we'll
+  // cache a sel_str is if we found a "selector specific stub" for the selector
+  // and conversely we only add to the SEL cache if we saw a regular dispatch.
   lldb::addr_t LookupInMethodCache(lldb::addr_t class_addr, lldb::addr_t sel);
+  lldb::addr_t LookupInMethodCache(lldb::addr_t class_addr,
+                                   llvm::StringRef sel_str);
 
   void AddToMethodCache(lldb::addr_t class_addr, lldb::addr_t sel,
                         lldb::addr_t impl_addr);
 
+  void AddToMethodCache(lldb::addr_t class_addr, llvm::StringRef sel_str,
+                        lldb::addr_t impl_addr);
+
   TypeAndOrName LookupInClassNameCache(lldb::addr_t class_addr);
 
   void AddToClassNameCache(lldb::addr_t class_addr, const char *name,
@@ -343,20 +352,22 @@ class ObjCLanguageRuntime : public LanguageRuntime {
   }
 
 private:
-  // We keep a map of <Class,Selector>->Implementation so we don't have to call
-  // the resolver function over and over.
+  // We keep two maps of <Class,Selector>->Implementation so we don't have
+  // to call the resolver function over and over.
+  // The first comes from regular obj_msgSend type dispatch, and maps the
+  // class + uniqued SEL value to an implementation.
+  // The second comes from the "selector-specific stubs", which are always
+  // of the form _objc_msgSend$SelectorName, so we don't know the uniqued
+  // selector, only the string name.
 
   // FIXME: We need to watch for the loading of Protocols, and flush the cache
   // for any
   // class that we see so changed.
 
   struct ClassAndSel {
-    ClassAndSel() {
-      sel_addr = LLDB_INVALID_ADDRESS;
-      class_addr = LLDB_INVALID_ADDRESS;
-    }
+    ClassAndSel() = default;
 
-    ClassAndSel(lldb::addr_t in_sel_addr, lldb::addr_t in_class_addr)
+    ClassAndSel(lldb::addr_t in_class_addr, lldb::addr_t in_sel_addr)
         : class_addr(in_class_addr), sel_addr(in_sel_addr) {}
 
     bool operator==(const ClassAndSel &rhs) {
@@ -379,18 +390,43 @@ class ObjCLanguageRuntime : public LanguageRuntime {
       }
     }
 
-    lldb::addr_t class_addr;
-    lldb::addr_t sel_addr;
+    lldb::addr_t class_addr = LLDB_INVALID_ADDRESS;
+    lldb::addr_t sel_addr = LLDB_INVALID_ADDRESS;
+  };
+
+  struct ClassAndSelStr {
+    ClassAndSelStr() = default;
+
+    ClassAndSelStr(lldb::addr_t in_class_addr, llvm::StringRef in_sel_name)
+        : class_addr(in_class_addr), sel_name(in_sel_name) {}
+
+    bool operator==(const ClassAndSelStr &rhs) {
+      return class_addr == rhs.class_addr && sel_name == rhs.sel_name;
+    }
+
+    bool operator<(const ClassAndSelStr &rhs) const {
+      if (class_addr < rhs.class_addr)
+        return true;
+      else if (class_addr > rhs.class_addr)
+        return false;
+      else
+        return ConstString::Compare(sel_name, rhs.sel_name);
+    }
+
+    lldb::addr_t class_addr = LLDB_INVALID_ADDRESS;
+    ConstString sel_name;
   };
 
   typedef std::map<ClassAndSel, lldb::addr_t> MsgImplMap;
+  typedef std::map<ClassAndSelStr, lldb::addr_t> MsgImplStrMap;
   typedef std::map<ObjCISA, ClassDescriptorSP> ISAToDescriptorMap;
   typedef std::multimap<uint32_t, ObjCISA> HashToISAMap;
   typedef ISAToDescriptorMap::iterator ISAToDescriptorIterator;
   typedef HashToISAMap::iterator HashToISAIterator;
   typedef ThreadSafeDenseMap<void *, uint64_t> TypeSizeCache;
 
   MsgImplMap m_impl_cache;
+  MsgImplStrMap m_impl_str_cache;
   LazyBool m_has_new_literals_and_indexing;
   ISAToDescriptorMap m_isa_to_descriptor;
   HashToISAMap m_hash_to_isa_map;

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h

@@ -56,7 +56,7 @@ def cleanup():
                 ' 21 key/value pairs'
             ])
 
-        lldbutil.run_break_set_by_regexp(self, 'setAtoms')
+        lldbutil.run_break_set_by_symbol(self, '-[Molecule setAtoms:]')
 
         self.runCmd("continue")
         self.expect("frame variable _cmd", substrs=['setAtoms:'])