[debugserver]Add platform cache support to improve performance.Under BigSur 11.3 this function causes a performance loss of 0.68s per execution.

[kuperxu]

[debugserver]Recalculate the platform cache each time the port is cleared.

[kuperxu]

The main reason for the problem is that dyld has modified the _dyld_process_info_create function implementation, which has increased the function's time consumption significantly and caused a huge delay in attaching the program.

[kuperxu]

Currently the main time consuming performance is when loading the executable. In the MachProcess::GetMachOInformationFromMemory function if the executable has 100 load_command, then the function _dyld_process_info_create will be executed 100 times

[JDevlieghere]

LGTM

[JDevlieghere]

Please let me know if you want me to land this for you.

[jasonmolenda]

LGTM, thanks for doing this.

[kuperxu]

I don't have permission to commit, please land this code.
Thank you @JDevlieghere

lldb/tools/debugserver/source/MacOSX/MachProcess.h

DeploymentInfo GetDeploymentInfo(const struct load_command &,
                                    bool is_executable);
   static const char *GetPlatformString(unsigned char platform);
   bool GetMachOInformationFromMemory(uint32_t platform,
                                      nub_addr_t mach_o_header_addr,
                                      int wordsize,
                                      struct mach_o_information &inf);
   JSONGenerator::ObjectSP FormatDynamicLibrariesIntoJSON(
       const std::vector<struct binary_image_information> &image_infos);
+  uint32_t GetPlatform();
   /// Get the runtime platform from DYLD via SPI.
   uint32_t GetProcessPlatformViaDYLDSPI();
   /// Use the dyld SPI present in macOS 10.12, iOS 10, tvOS 10,
   /// watchOS 3 and newer to get the load address, uuid, and filenames
   /// of all the libraries.  This only fills in those three fields in
   /// the 'struct binary_image_information' - call
   /// GetMachOInformationFromMemory to fill in the mach-o header/load
   /// command details.
private:
   void StopProfileThread();
 
   uint32_t Flags() const { return m_flags; }
   nub_state_t DoSIGSTOP(bool clear_bps_and_wps, bool allow_running,
                         uint32_t *thread_idx_ptr);
 
   pid_t m_pid;           // Process ID of child process
   cpu_type_t m_cpu_type; // The CPU type of this process
+  uint32_t m_platform;   // The platform of this process
   int m_child_stdin;
   int m_child_stdout;
   int m_child_stderr;
   std::string m_path; // A path to the executable if we have one
   std::vector<std::string>
       m_args;              // The arguments with which the process was lauched
   int m_exit_status;       // The exit status for the process
   std::string m_exit_info; // Any extra info that we may have about the exit

lldb/tools/debugserver/source/MacOSX/MachProcess.mm

#if defined(LC_BUILD_VERSION)
   }
 #endif
   }
 
   // The xctest binary is a pure macOS binary but is launched with
   // DYLD_FORCE_PLATFORM=6. In that case, force the platform to
   // macCatalyst and use the macCatalyst version of the host OS
   // instead of the macOS deployment target.
-  if (is_executable && GetProcessPlatformViaDYLDSPI() == PLATFORM_MACCATALYST) {
+  if (is_executable && GetPlatform() == PLATFORM_MACCATALYST) {
     info.platform = PLATFORM_MACCATALYST;
     std::string catalyst_version = GetMacCatalystVersionString();
     const char *major = catalyst_version.c_str();
     char *minor = nullptr;
     char *patch = nullptr;
     info.major_version = std::strtoul(major, &minor, 10);
     info.minor_version = 0;
     info.patch_version = 0;
struct dyld_process_cache_info {
   /// Load address of dyld shared cache.
   uint64_t cacheBaseAddress;
   /// Process is running without a dyld cache.
   bool noCache;
   /// Process is using a private copy of its dyld cache.
   bool privateCache;
 };
 
+uint32_t MachProcess::GetPlatform() {
+  if (m_platform == 0)
+    m_platform = MachProcess::GetProcessPlatformViaDYLDSPI();
+  return m_platform;
+}
+
 uint32_t MachProcess::GetProcessPlatformViaDYLDSPI() {
   kern_return_t kern_ret;
   uint32_t platform = 0;
   if (m_dyld_process_info_create) {
     dyld_process_info info =
         m_dyld_process_info_create(m_task.TaskPort(), 0, &kern_ret);
     if (info) {
       if (m_dyld_process_info_get_platform)

 // macOS 10.12, iOS 10, tvOS 10, watchOS 3 and newer.
 JSONGenerator::ObjectSP
 MachProcess::GetAllLoadedLibrariesInfos(nub_process_t pid) {
   JSONGenerator::DictionarySP reply_sp;
 
   int pointer_size = GetInferiorAddrSize(pid);
   std::vector<struct binary_image_information> image_infos;
   GetAllLoadedBinariesViaDYLDSPI(image_infos);
-  uint32_t platform = GetProcessPlatformViaDYLDSPI();
+  uint32_t platform = GetPlatform();
   const size_t image_count = image_infos.size();
   for (size_t i = 0; i < image_count; i++) {
     GetMachOInformationFromMemory(platform, image_infos[i].load_address,
                                   pointer_size, image_infos[i].macho_info);
   }
     return FormatDynamicLibrariesIntoJSON(image_infos);
 }
 
 // Fetch information about the shared libraries at the given load addresses
 // using the
 // dyld SPIs that exist in macOS 10.12, iOS 10, tvOS 10, watchOS 3 and newer.
 JSONGenerator::ObjectSP MachProcess::GetLibrariesInfoForAddresses(
     nub_process_t pid, std::vector<uint64_t> &macho_addresses) {
   JSONGenerator::DictionarySP reply_sp;
 
   int pointer_size = GetInferiorAddrSize(pid);
 
   std::vector<struct binary_image_information> all_image_infos;
   GetAllLoadedBinariesViaDYLDSPI(all_image_infos);
-  uint32_t platform = GetProcessPlatformViaDYLDSPI();
+  uint32_t platform = GetPlatform();
 
   std::vector<struct binary_image_information> image_infos;
   const size_t macho_addresses_count = macho_addresses.size();
   const size_t all_image_infos_count = all_image_infos.size();
   for (size_t i = 0; i < macho_addresses_count; i++) {
     for (size_t j = 0; j < all_image_infos_count; j++) {
       if (all_image_infos[j].load_address == macho_addresses[i]) {
         image_infos.push_back(all_image_infos[j]);
if (event_mask != 0) {
     m_events.WaitForResetAck(event_mask);
   }
 }
 
 void MachProcess::Clear(bool detaching) {
   // Clear any cached thread list while the pid and task are still valid
 
   m_task.Clear();
+  m_platform = 0;
   // Now clear out all member variables
   m_pid = INVALID_NUB_PROCESS;
   if (!detaching)
     CloseChildFileDescriptors();
 
   m_path.clear();
   m_args.clear();
   SetState(eStateUnloaded);
bool MachProcess::Detach() {
   if (DNBLogCheckLogBit(LOG_PROCESS) || err.Fail() || (ret != 0))
     err.LogThreaded("::ptrace (PT_DETACH, %u, (caddr_t)1, 0)", pid);
 
   // Resume our task
   m_task.Resume();
 
   // NULL our task out as we have already restored all exception ports
   m_task.Clear();
+  m_platform = 0;
 
   // Clear out any notion of the process we once were
   const bool detaching = true;
   Clear(detaching);
 
   SetState(eStateDetached);
 
   return true;