PlatformDarwinKernel::GetSupportedArchitectures should report all supported architectures

[jasonmolenda]

Summary

PlatformDarwinKernel had an old idiom in its GetSupportedArchitectures method, which would turn the list of supported architectures based on the compile-time debug host. This doesn't make any sense; you can debug an arm kernel from an x86 mac, but it usually didn't cause any obvious problems so it went unnoticed. Fix that.

Also some NFC changes to Target::SetArchitecture log messages, to make it easier to track the Target's architecture as it is refined/updated.

[jasonmolenda]

I should note that PlatformDarwin::ARMGetSupportedArchitectures and PlatformDarwin::x86GetSupportedArchitectures append the entries to the vector passed in, so calling them in sequence is fine.

[JDevlieghere]

LGTM

lldb/source/Target/Target.cpp

1550–1556

If you use LLDB_LOG you could drop the .c_str()

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

bool PlatformDarwinKernel::LoadPlatformBinaryAndSetup(Process *process,
   process->SetDynamicLoader(std::move(dyld_up));
 
   return true;
 }
 
 std::vector<ArchSpec> PlatformDarwinKernel::GetSupportedArchitectures(
     const ArchSpec &process_host_arch) {
   std::vector<ArchSpec> result;
-#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
   ARMGetSupportedArchitectures(result);
-#else
   x86GetSupportedArchitectures(result);
-#endif
   return result;
 }
 
 void PlatformDarwinKernel::CalculateTrapHandlerSymbolNames() {
   m_trap_handlers.push_back(ConstString("trap_from_kernel"));
   m_trap_handlers.push_back(ConstString("hndl_machine_check"));
   m_trap_handlers.push_back(ConstString("hndl_double_fault"));
   m_trap_handlers.push_back(ConstString("hndl_allintrs"));

lldb/source/Target/Target.cpp

if (executable_sp) {
     m_images.Append(executable_sp,
                     notify); // The first image is our executable file
 
     // If we haven't set an architecture yet, reset our architecture based on
     // what we found in the executable module.
     if (!m_arch.GetSpec().IsValid()) {
       m_arch = executable_sp->GetArchitecture();
       LLDB_LOG(log,
-               "setting architecture to {0} ({1}) based on executable file",
+               "Target::SetExecutableModule setting architecture to {0} ({1}) "
+               "based on executable file",
                m_arch.GetSpec().GetArchitectureName(),
                m_arch.GetSpec().GetTriple().getTriple());
     }
 
     FileSpecList dependent_files;
     ObjectFile *executable_objfile = executable_sp->GetObjectFile();
     bool load_dependents = true;
     switch (load_dependent_files) {
bool Target::SetArchitecture(const ArchSpec &arch_spec, bool set_platform,
   }
 
   if (compatible_local_arch || missing_local_arch) {
     // If we haven't got a valid arch spec, or the architectures are compatible
     // update the architecture, unless the one we already have is more
     // specified
     if (replace_local_arch)
       m_arch = other;
-    LLDB_LOG(log, "set architecture to {0} ({1})",
+    LLDB_LOG(log,
+             "Target::SetArchitecture merging compatible arch; arch "
+             "is now {0} ({1})",
              m_arch.GetSpec().GetArchitectureName(),
              m_arch.GetSpec().GetTriple().getTriple());
     return true;
   }
 
   // If we have an executable file, try to reset the executable to the desired
   // architecture
-  LLDB_LOGF(log, "Target::SetArchitecture changing architecture to %s (%s)",
-            arch_spec.GetArchitectureName(),
-            arch_spec.GetTriple().getTriple().c_str());
+  LLDB_LOGF(
+      log,
+      "Target::SetArchitecture changing architecture to %s (%s) from %s (%s)",
+      arch_spec.GetTriple().getTriple().c_str(),
+      m_arch.GetSpec().GetArchitectureName(),
+      m_arch.GetSpec().GetTriple().getTriple().c_str());
   m_arch = other;
   ModuleSP executable_sp = GetExecutableModule();
 
   ClearModules(true);
   // Need to do something about unsetting breakpoints.
 
   if (executable_sp) {
     LLDB_LOGF(log,