[Target] Generalize some behavior in Target::SymbolsDidLoad

[xiaobai]

Summary

SymbolsDidLoad is currently only implemented for ObjCLanguageRuntime,
but that doesn't mean that it couldn't be useful for other Langauges. Although
this change seems like it's generalizing for the sake of purity, this removes
Target's dependency on ObjCLanguageRuntime.

[labath]

source/Target/Target.cpp

1669–1672

Same question about runtime iteration as in the other review.

[clayborg]

Seems like we need a Process::SymbolsDidLoad(...) function that we can call. It should iterate over all loaded language runtimes (only loaded ones) and forward the list.

source/Target/Target.cpp

1669–1670

Seems like we should add a Process::SymbolsDidLoad() method that matches this method's signature and just call that. Process would iterate across all loaded language runtimes and call SymbolsDidLoad on any?

[xiaobai]

source/Target/Target.cpp

1669–1670

Instead of adding Process::SymbolsDidLoad, I could instead iterate here over the loaded language runtimes with Process::GetLanguageRuntimes and call LanguageRuntime::SymbolsDidLoad on each one. What do you think? This would prevent us from having 3 classes with the method SymbolsDidLoad with the same signature.

1669–1672

Right, we should definitely iterate over loaded language runtimes instead of just using the ObjC runtime. Will update.

[clayborg]

source/Target/Target.cpp

1669–1670

That is fine as long as we iterate over all loaded language runtimes I am good.

[xiaobai]

Address comments

include/lldb/Target/LanguageRuntime.h

public:
 
   virtual lldb::SearchFilterSP CreateExceptionSearchFilter();
 
   virtual bool GetTypeBitSize(const CompilerType &compiler_type,
                               uint64_t &size) {
     return false;
   }
 
+  virtual void SymbolsDidLoad(const ModuleList &module_list) { return; }
+
   virtual lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
                                                           bool stop_others) = 0;
 
   /// Identify whether a value is a language implementation detaul
   /// that should be hidden from the user interface by default.
   virtual bool IsRuntimeSupportValue(ValueObject &valobj) { return false; }
 
   virtual void ModulesDidLoad(const ModuleList &module_list) {}

include/lldb/Target/ObjCLanguageRuntime.h

if (m_has_new_literals_and_indexing == eLazyBoolCalculate) {
         m_has_new_literals_and_indexing = eLazyBoolYes;
       else
         m_has_new_literals_and_indexing = eLazyBoolNo;
     }
 
     return (m_has_new_literals_and_indexing == eLazyBoolYes);
   }
 
-  virtual void SymbolsDidLoad(const ModuleList &module_list) {
+  void SymbolsDidLoad(const ModuleList &module_list) override {
     m_negative_complete_class_cache.clear();
   }
 
   bool GetTypeBitSize(const CompilerType &compiler_type,
                       uint64_t &size) override;
 
   /// Check whether the name is "self" or "_cmd" and should show up in
   /// "frame variable".

source/Target/Target.cpp

 #include "lldb/Interpreter/OptionValues.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/LanguageRuntime.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/FileSpec.h"
if (m_valid && num_images) {
     }
     BroadcastEvent(eBroadcastBitModulesLoaded,
                    new TargetEventData(this->shared_from_this(), module_list));
   }
 }
 
 void Target::SymbolsDidLoad(ModuleList &module_list) {
   if (m_valid && module_list.GetSize()) {
     if (m_process_sp) {
-      LanguageRuntime *runtime =
-          m_process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
-      if (runtime) {
-        ObjCLanguageRuntime *objc_runtime = (ObjCLanguageRuntime *)runtime;
-        objc_runtime->SymbolsDidLoad(module_list);
+      for (LanguageRuntime *runtime : m_process_sp->GetLanguageRuntimes()) {
+        runtime->SymbolsDidLoad(module_list);
       }
     }
 
     m_breakpoint_list.UpdateBreakpoints(module_list, true, false);
     m_internal_breakpoint_list.UpdateBreakpoints(module_list, true, false);
     BroadcastEvent(eBroadcastBitSymbolsLoaded,
                    new TargetEventData(this->shared_from_this(), module_list));
   }
 }