[Platform] Accept arbitrary kext variants

[JDevlieghere]

Summary

When loading kexts in PlatformDarwinKernel, we use the BundleID as the filename to to create shared modules. In GetSharedModule we call ExamineKextForMatchingUUID for any BundleID it finds that is a match, to see if the UUID is also a match. Until now we were using Host::ResolveExecutableInBundle whcih calls a CoreFoundation API to obtain the executable. However, it's possible that the executable has a variant suffix (e.g. foo_development) and these files were ignored.

This patch replaces that call with logic that looks for all the binaries in the bundle. Because of the way ExamineKextForMatchingUUID works, it's fine to try to load executables that are not valid and we can just iterate over the list until we found a match.

[JDevlieghere]

Don't use EnumerateDirectory

[jasonmolenda]

LGTM. If we added more knowledge specifically about kext bundle layouts, we could restrict which files we test to see if they are valid binaries - but we'd need to parse the Info.plist at the top (to get the CFBundleExecutable name, and look for variations on that prefix) and we'd need to handle shallow/deep kext bundles. Given how few files are in kext bundles besides the kexts themselves (a couple of plists), this is code is much simpler than encoding all that extra specifics about kexts.

[JDevlieghere]

In D47539#1117114, @jasonmolenda wrote:

LGTM. If we added more knowledge specifically about kext bundle layouts, we could restrict which files we test to see if they are valid binaries - but we'd need to parse the Info.plist at the top (to get the CFBundleExecutable name, and look for variations on that prefix) and we'd need to handle shallow/deep kext bundles. Given how few files are in kext bundles besides the kexts themselves (a couple of plists), this is code is much simpler than encoding all that extra specifics about kexts.

Thanks Jason!

Currently there are no kext test currently. Jason and I had a brief discussion yesterday on how we could do this in the future, but while it is certainly possible (and something I want to do) it's going to be too much work for this small change. Unless anyone has a practical idea for a test I'm going to land this as is, awaiting the aforementioned kext test infrastructure.

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.h

GetKernelsAndKextsInDirectoryNoRecursion(
       void *baton, llvm::sys::fs::file_type ft,
       const lldb_private::FileSpec &file_spec);
 
   static lldb_private::FileSpec::EnumerateDirectoryResult
   GetKernelsAndKextsInDirectoryHelper(void *baton, llvm::sys::fs::file_type ft,
                                       const lldb_private::FileSpec &file_spec,
                                       bool recurse);
 
+  static std::vector<lldb_private::FileSpec>
+  SearchForExecutablesRecursively(const lldb_private::ConstString &dir);
+
   static void AddKextToMap(PlatformDarwinKernel *thisp,
                            const lldb_private::FileSpec &file_spec);
 
   // Returns true if there is a .dSYM bundle next to the kext, or next to the
   // binary inside the kext.
   static bool
   KextHasdSYMSibling(const lldb_private::FileSpec &kext_bundle_filepath);
 

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

for (auto possible_kernel : m_kernel_binaries_without_dsyms) {
         }
       }
     }
   }
 
   return error;
 }
 
+std::vector<lldb_private::FileSpec>
+PlatformDarwinKernel::SearchForExecutablesRecursively(const ConstString &dir) {
+  std::vector<FileSpec> executables;
+  std::error_code EC;
+  for (llvm::sys::fs::recursive_directory_iterator it(dir.GetStringRef(), EC),
+       end;
+       it != end && !EC; it.increment(EC)) {
+    auto status = it->status();
+    if (!status)
+      break;
+    if (llvm::sys::fs::is_regular_file(*status) &&
+        llvm::sys::fs::can_execute(it->path()))
+      executables.emplace_back(it->path(), false);
+  }
+  return executables;
+}
+
 Status PlatformDarwinKernel::ExamineKextForMatchingUUID(
     const FileSpec &kext_bundle_path, const lldb_private::UUID &uuid,
     const ArchSpec &arch, ModuleSP &exe_module_sp) {
-  Status error;
-  FileSpec exe_file = kext_bundle_path;
-  Host::ResolveExecutableInBundle(exe_file);
+  for (const auto &exe_file :
+       SearchForExecutablesRecursively(kext_bundle_path.GetDirectory())) {
     if (exe_file.Exists()) {
       ModuleSpec exe_spec(exe_file);
       exe_spec.GetUUID() = uuid;
       if (!uuid.IsValid()) {
         exe_spec.GetArchitecture() = arch;
       }
 
       // First try to create a ModuleSP with the file / arch and see if the UUID
       // matches. If that fails (this exec file doesn't have the correct uuid),
       // don't call GetSharedModule (which may call in to the DebugSymbols
       // framework and therefore can be slow.)
       ModuleSP module_sp(new Module(exe_spec));
       if (module_sp && module_sp->GetObjectFile() &&
           module_sp->MatchesModuleSpec(exe_spec)) {
-      error = ModuleList::GetSharedModule(exe_spec, exe_module_sp, NULL, NULL,
-                                          NULL);
+        Status error = ModuleList::GetSharedModule(exe_spec, exe_module_sp,
+                                                   NULL, NULL, NULL);
         if (exe_module_sp && exe_module_sp->GetObjectFile()) {
           return error;
         }
       }
       exe_module_sp.reset();
     }
-  return error;
+  }
+
+  return {};
 }
 
 bool PlatformDarwinKernel::GetSupportedArchitectureAtIndex(uint32_t idx,
                                                            ArchSpec &arch) {
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
   return ARMGetSupportedArchitectureAtIndex(idx, arch);
 #else
   return x86GetSupportedArchitectureAtIndex(idx, arch);