Implement GetSystemIncludeDirectories for macOS

[teemperor]

Summary

GetSystemIncludeDirectories is currently only implemented for Linux where it returns /usr/include with a potential sysroot
as a prefix. This patch implements the equivalent functionality on macOS.

[aprantl]

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

244

I'm not 100% sure if that is how Clang header search works, but I believe that these paths should be returned relative to the sysroot, no?

244

... and we should set sysroot separately.

244

Doing it this way may work but it would be different from how a regular clang invocation works, and that is prone to subtle bugs.

[teemperor]

This is no longer necessary as we abandon the "reimplement include directories" approach (we now look at the support files or require -gmodules which both provide the same information in a more reliable way).

lldb/include/lldb/Target/Platform.h

virtual ArchSpec GetRemoteSystemArchitecture() {
     return ArchSpec(); // Return an invalid architecture
   }
 
   virtual FileSpec GetRemoteWorkingDirectory() { return m_working_dir; }
 
   virtual bool SetRemoteWorkingDirectory(const FileSpec &working_dir);
 
   /// Retrieve the system include directories on this platform for the
-  /// given language.
+  /// given language and target.
   ///
   /// \param[in] lang
   ///     The language for which the include directories should be queried.
   ///
+  /// \param[in] target
+  ///     The target for which the include directories should be queried.
+  ///
   /// \param[out] directories
   ///     The include directories for this system.
   virtual std::vector<std::string>
-  GetSystemIncludeDirectories(lldb::LanguageType lang) {
+  GetSystemIncludeDirectories(lldb::LanguageType lang,
+                              lldb_private::Target &target) {
     return {};
   }
 
   virtual UserIDResolver &GetUserIDResolver() = 0;
 
   /// Locate a file for a platform.
   ///
   /// The default implementation of this function will return the same file

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

public:
 
   clang::TextDiagnosticBuffer *GetPassthrough() { return m_passthrough.get(); }
 
 private:
   DiagnosticManager *m_manager = nullptr;
   std::shared_ptr<clang::TextDiagnosticBuffer> m_passthrough;
 };
 
-static void
-SetupModuleHeaderPaths(CompilerInstance *compiler,
+static void SetupModuleHeaderPaths(CompilerInstance *compiler,
                                    std::vector<ConstString> include_directories,
-                       lldb::TargetSP target_sp) {
+                                   lldb_private::Target &target) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   HeaderSearchOptions &search_opts = compiler->getHeaderSearchOpts();
 
   for (ConstString dir : include_directories) {
     search_opts.AddPath(dir.AsCString(), frontend::System, false, true);
     LLDB_LOG(log, "Added user include dir: {0}", dir);
   }
if (FileSystem::Instance().IsDirectory(resource_dir)) {
     search_opts.AddPath(resource_include, frontend::System, false, true);
 
     LLDB_LOG(log, "Added resource include dir: {0}", resource_include);
   }
 
   search_opts.ImplicitModuleMaps = true;
 
   std::vector<std::string> system_include_directories =
-      target_sp->GetPlatform()->GetSystemIncludeDirectories(
-          lldb::eLanguageTypeC_plus_plus);
+      target.GetPlatform()->GetSystemIncludeDirectories(
+          lldb::eLanguageTypeC_plus_plus, target);
 
   for (const std::string &include_dir : system_include_directories) {
     search_opts.AddPath(include_dir, frontend::System, false, true);
 
     LLDB_LOG(log, "Added system include dir: {0}", include_dir);
   }
 }
 
if (clang_expr && clang_expr->DidImportCxxModules()) {
 
     // Options we need to parse libc++ code successfully.
     // FIXME: We should ask the driver for the appropriate default flags.
     lang_opts.GNUMode = true;
     lang_opts.GNUKeywords = true;
     lang_opts.DoubleSquareBracketAttributes = true;
     lang_opts.CPlusPlus11 = true;
 
-    SetupModuleHeaderPaths(m_compiler.get(), m_include_directories,
-                           target_sp);
+    SetupModuleHeaderPaths(m_compiler.get(), m_include_directories, *target_sp);
   }
 
   if (process_sp && lang_opts.ObjC) {
     if (process_sp->GetObjCLanguageRuntime()) {
       if (process_sp->GetObjCLanguageRuntime()->GetRuntimeVersion() ==
           ObjCLanguageRuntime::ObjCRuntimeVersions::eAppleObjC_V2)
         lang_opts.ObjCRuntime.set(ObjCRuntime::MacOSX, VersionTuple(10, 7));
       else

lldb/source/Plugins/Platform/Linux/PlatformLinux.h

public:
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx, ArchSpec &arch) override;
 
   int32_t GetResumeCountForLaunchInfo(ProcessLaunchInfo &launch_info) override;
 
   bool CanDebugProcess() override;
 
   std::vector<std::string>
-  GetSystemIncludeDirectories(lldb::LanguageType lang) override;
+  GetSystemIncludeDirectories(lldb::LanguageType lang,
+                              lldb_private::Target &target) override;
 
   lldb::ProcessSP DebugProcess(ProcessLaunchInfo &launch_info,
                                Debugger &debugger, Target *target,
                                Status &error) override;
 
   void CalculateTrapHandlerSymbolNames() override;
 
   MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

if (IsHost()) {
     return true;
   } else {
     // If we're connected, we can debug.
     return IsConnected();
   }
 }
 
 std::vector<std::string>
-PlatformLinux::GetSystemIncludeDirectories(lldb::LanguageType lang) {
+PlatformLinux::GetSystemIncludeDirectories(lldb::LanguageType lang,
+                                           lldb_private::Target &target) {
   std::string sys_root = GetSDKRootDirectory().AsCString("");
   switch (lang) {
   case lldb::eLanguageTypeC:
   case lldb::eLanguageTypeC89:
   case lldb::eLanguageTypeC99:
   case lldb::eLanguageTypeC11:
   case lldb::eLanguageTypeC_plus_plus:
   case lldb::eLanguageTypeC_plus_plus_03:

lldb/source/Plugins/Platform/MacOSX/PlatformMacOSX.h

GetFileWithUUID(const lldb_private::FileSpec &platform_file,
                   lldb_private::FileSpec &local_file) override;
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx,
                                        lldb_private::ArchSpec &arch) override;
 
   lldb_private::ConstString
   GetSDKDirectory(lldb_private::Target &target) override;
 
+  std::vector<std::string>
+  GetSystemIncludeDirectories(lldb::LanguageType lang,
+                              lldb_private::Target &target) override;
+
   void
   AddClangModuleCompilationOptions(lldb_private::Target *target,
                                    std::vector<std::string> &options) override {
     return PlatformDarwin::AddClangModuleCompilationOptionsForSDKType(
         target, options, PlatformDarwin::SDKType::MacOSX);
   }
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformMacOSX);
 };
 
 #endif // liblldb_PlatformMacOSX_h_

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

if (objfile) {
             return ConstString(default_xcode_sdk);
         }
       }
     }
   }
   return ConstString();
 }
 
+std::vector<std::string>
+PlatformMacOSX::GetSystemIncludeDirectories(LanguageType lang,
+                                            lldb_private::Target &target) {
+  std::string sys_root = GetSDKDirectory(target).AsCString("");
+  switch (lang) {
+  case lldb::eLanguageTypeC:
+  case lldb::eLanguageTypeC89:
+  case lldb::eLanguageTypeC99:
+  case lldb::eLanguageTypeC11:
+  case lldb::eLanguageTypeC_plus_plus:
+  case lldb::eLanguageTypeC_plus_plus_03:
+  case lldb::eLanguageTypeC_plus_plus_11:
+  case lldb::eLanguageTypeC_plus_plus_14:
+  case lldb::eLanguageTypeObjC:
+  case lldb::eLanguageTypeObjC_plus_plus:
+    return {sys_root + "/usr/include/"};
+  default:
+    return {};
+  }
+}
+
 Status PlatformMacOSX::GetSymbolFile(const FileSpec &platform_file,
                                      const UUID *uuid_ptr,
                                      FileSpec &local_file) {
   if (IsRemote()) {
     if (m_remote_platform_sp)
       return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
                                                    local_file);
   }