[lldb][nfc] Create helper functions in SwiftLanguageRuntimeNames

These will be useful to reuse code in upcoming commits.

Author: felipepiovezan

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeNames.cpp

@@ -419,6 +419,59 @@ CreateRunThroughTaskSwitchingTrampolines(Thread &thread,
   return nullptr;
 }
 
+/// Demangle `symbol_name` and extracts the text at the node described by
+/// `node_path`, if it exists; otherwise, returns an empty string.
+static std::string FindClassName(StringRef symbol_name,
+                                 llvm::ArrayRef<Node::Kind> node_path) {
+  swift::Demangle::Context ctx;
+  NodePointer demangled_node =
+      SwiftLanguageRuntime::DemangleSymbolAsNode(symbol_name, ctx);
+
+  NodePointer class_node = childAtPath(demangled_node, node_path);
+  if (!class_node || !class_node->hasText()) {
+    std::string node_str = getNodeTreeAsString(demangled_node);
+    LLDB_LOGF(GetLog(LLDBLog::Step),
+              "SwiftLanguageRuntime: failed to extract name from "
+              "demangle node: %s",
+              node_str.c_str());
+    return "";
+  }
+  return class_node->getText().str();
+}
+
+/// If sc_list is non-empty, returns a plan that runs to any of its addresses.
+/// Otherwise, returns nullptr.
+static ThreadPlanSP
+CreateThreadPlanRunToSCInList(Thread &thread, const SymbolContextList &sc_list,
+                              bool stop_others) {
+  std::vector<addr_t> load_addresses;
+  Target &target = thread.GetProcess()->GetTarget();
+  for (const SymbolContext &sc : sc_list) {
+    const Symbol *ctor_symbol = sc.symbol;
+    if (ctor_symbol)
+      load_addresses.push_back(ctor_symbol->GetLoadAddress(&target));
+  }
+
+  if (load_addresses.empty()) {
+    LLDB_LOG(GetLog(LLDBLog::Step),
+             "SwiftLanguageRuntime: empty sc_list found.");
+    return {};
+  }
+  return std::make_shared<ThreadPlanRunToAddress>(thread, load_addresses,
+                                                  stop_others);
+}
+
+/// Search all modules for `target_func` and creates a RunToAddress plan
+/// targeting all symbols found.
+static ThreadPlanSP CreateRunToAddressPlan(StringRef target_func,
+                                           Thread &thread, bool stop_others) {
+  ModuleList modules = thread.GetProcess()->GetTarget().GetImages();
+  SymbolContextList sc_list;
+  modules.FindFunctionSymbols(ConstString(target_func), eFunctionNameTypeFull,
+                              sc_list);
+  return CreateThreadPlanRunToSCInList(thread, sc_list, stop_others);
+}
+
 static lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
                                                        bool stop_others) {
   // Here are the trampolines we have at present.
@@ -475,19 +528,7 @@ static lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
       log->Printf(
           "Stepped to thunk \"%s\" (kind: %s) stepping to target: \"%s\".",
           symbol_name, GetThunkKindName(thunk_kind), thunk_target.c_str());
-
-    ModuleList modules = thread.GetProcess()->GetTarget().GetImages();
-    SymbolContextList sc_list;
-    modules.FindFunctionSymbols(ConstString(thunk_target),
-                                eFunctionNameTypeFull, sc_list);
-    if (sc_list.GetSize() == 1 && sc_list[0].symbol) {
-      Symbol &thunk_symbol = *sc_list[0].symbol;
-      Address target_address = thunk_symbol.GetAddress();
-      if (target_address.IsValid())
-        return std::make_shared<ThreadPlanRunToAddress>(thread, target_address,
-                                                        stop_others);
-    }
-    return nullptr;
+    return CreateRunToAddressPlan(thunk_target, thread, stop_others);
   }
   case ThunkAction::StepIntoConformance: {
     // The TTW symbols encode the protocol conformance requirements
@@ -582,37 +623,19 @@ static lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
   }
   case ThunkAction::StepIntoAllocatingInit: {
     LLDB_LOGF(log, "Stepping into allocating init: \"%s\"", symbol_name);
-    swift::Demangle::Context ctx;
-    NodePointer demangled_node =
-        SwiftLanguageRuntime::DemangleSymbolAsNode(symbol_name, ctx);
-
     using Kind = Node::Kind;
-    NodePointer class_node = childAtPath(
-        demangled_node, {Kind::Allocator, Kind::Class, Kind::Identifier});
-    if (!class_node || !class_node->hasText()) {
-      std::string node_str = getNodeTreeAsString(demangled_node);
-      LLDB_LOGF(log,
-                "Failed to extract constructor name from demangle node: %s",
-                node_str.c_str());
+    static constexpr auto class_path = {Kind::Allocator, Kind::Class,
+                                        Kind::Identifier};
+    std::string class_name = FindClassName(symbol_name, class_path);
+    if (class_name.empty())
       return nullptr;
-    }
 
     ModuleFunctionSearchOptions options{/*include_symbols*/ true,
                                         /*include_inlines*/ true};
-    std::string ctor_name = llvm::formatv("{0}.init", class_node->getText());
+    std::string ctor_name = llvm::formatv("{0}.init", class_name);
     SymbolContextList sc_list;
     sc.module_sp->FindFunctions(RegularExpression(ctor_name), options, sc_list);
-    std::vector<addr_t> load_addresses;
-    Target &target = thread.GetProcess()->GetTarget();
-    for (const SymbolContext &ctor_sc : sc_list) {
-      const Symbol *ctor_symbol = ctor_sc.symbol;
-      if (ctor_symbol)
-        load_addresses.push_back(ctor_symbol->GetLoadAddress(&target));
-    }
-    if (load_addresses.empty())
-      return nullptr;
-    return std::make_shared<ThreadPlanRunToAddress>(thread, load_addresses,
-                                                    stop_others);
+    return CreateThreadPlanRunToSCInList(thread, sc_list, stop_others);
   }
   case ThunkAction::StepThrough: {
     if (log)