1 //===-- CppModuleConfiguration.cpp ----------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "CppModuleConfiguration.h"
10 
11 #include "ClangHost.h"
12 #include "lldb/Host/FileSystem.h"
13 #include "llvm/ADT/Triple.h"
14 
15 using namespace lldb_private;
16 
17 bool CppModuleConfiguration::SetOncePath::TrySet(llvm::StringRef path) {
18   // Setting for the first time always works.
19   if (m_first) {
20     m_path = path.str();
21     m_valid = true;
22     m_first = false;
23     return true;
24   }
25   // Changing the path to the same value is fine.
26   if (m_path == path)
27     return true;
28 
29   // Changing the path after it was already set is not allowed.
30   m_valid = false;
31   return false;
32 }
33 
34 static llvm::SmallVector<std::string, 2>
35 getTargetIncludePaths(const llvm::Triple &triple) {
36   llvm::SmallVector<std::string, 2> paths;
37   if (!triple.str().empty()) {
38     paths.push_back("/usr/include/" + triple.str());
39     if (!triple.getArchName().empty() ||
40         triple.getOSAndEnvironmentName().empty())
41       paths.push_back(("/usr/include/" + triple.getArchName() + "-" +
42                        triple.getOSAndEnvironmentName())
43                           .str());
44   }
45   return paths;
46 }
47 
48 /// Returns the include path matching the given pattern for the given file
49 /// path (or None if the path doesn't match the pattern).
50 static llvm::Optional<llvm::StringRef>
51 guessIncludePath(llvm::StringRef path_to_file, llvm::StringRef pattern) {
52   if (pattern.empty())
53     return llvm::NoneType();
54   size_t pos = path_to_file.find(pattern);
55   if (pos == llvm::StringRef::npos)
56     return llvm::NoneType();
57 
58   return path_to_file.substr(0, pos + pattern.size());
59 }
60 
61 bool CppModuleConfiguration::analyzeFile(const FileSpec &f,
62                                          const llvm::Triple &triple) {
63   using namespace llvm::sys::path;
64   // Convert to slashes to make following operations simpler.
65   std::string dir_buffer = convert_to_slash(f.GetDirectory().GetStringRef());
66   llvm::StringRef posix_dir(dir_buffer);
67 
68   // Check for /c++/vX/ that is used by libc++.
69   static llvm::Regex libcpp_regex(R"regex(/c[+][+]/v[0-9]/)regex");
70   // If the path is in the libc++ include directory use it as the found libc++
71   // path. Ignore subdirectories such as /c++/v1/experimental as those don't
72   // need to be specified in the header search.
73   if (libcpp_regex.match(f.GetPath()) &&
74       parent_path(posix_dir, Style::posix).endswith("c++")) {
75     if (!m_std_inc.TrySet(posix_dir))
76       return false;
77     if (triple.str().empty())
78       return true;
79 
80     posix_dir.consume_back("c++/v1");
81     // Check if this is a target-specific libc++ include directory.
82     return m_std_target_inc.TrySet(
83         (posix_dir + triple.str() + "/c++/v1").str());
84   }
85 
86   llvm::Optional<llvm::StringRef> inc_path;
87   // Target specific paths contains /usr/include, so we check them first
88   for (auto &path : getTargetIncludePaths(triple)) {
89     if ((inc_path = guessIncludePath(posix_dir, path)))
90       return m_c_target_inc.TrySet(*inc_path);
91   }
92   if ((inc_path = guessIncludePath(posix_dir, "/usr/include")))
93     return m_c_inc.TrySet(*inc_path);
94 
95   // File wasn't interesting, continue analyzing.
96   return true;
97 }
98 
99 /// Utility function for just appending two paths.
100 static std::string MakePath(llvm::StringRef lhs, llvm::StringRef rhs) {
101   llvm::SmallString<256> result(lhs);
102   llvm::sys::path::append(result, rhs);
103   return std::string(result);
104 }
105 
106 bool CppModuleConfiguration::hasValidConfig() {
107   // We need to have a C and C++ include dir for a valid configuration.
108   if (!m_c_inc.Valid() || !m_std_inc.Valid())
109     return false;
110 
111   // Do some basic sanity checks on the directories that we don't activate
112   // the module when it's clear that it's not usable.
113   const std::vector<std::string> files_to_check = {
114       // * Check that the C library contains at least one random C standard
115       //   library header.
116       MakePath(m_c_inc.Get(), "stdio.h"),
117       // * Without a libc++ modulemap file we can't have a 'std' module that
118       //   could be imported.
119       MakePath(m_std_inc.Get(), "module.modulemap"),
120       // * Check for a random libc++ header (vector in this case) that has to
121       //   exist in a working libc++ setup.
122       MakePath(m_std_inc.Get(), "vector"),
123   };
124 
125   for (llvm::StringRef file_to_check : files_to_check) {
126     if (!FileSystem::Instance().Exists(file_to_check))
127       return false;
128   }
129 
130   return true;
131 }
132 
133 CppModuleConfiguration::CppModuleConfiguration(
134     const FileSpecList &support_files, const llvm::Triple &triple) {
135   // Analyze all files we were given to build the configuration.
136   bool error = !llvm::all_of(support_files,
137                              std::bind(&CppModuleConfiguration::analyzeFile,
138                                        this, std::placeholders::_1, triple));
139   // If we have a valid configuration at this point, set the
140   // include directories and module list that should be used.
141   if (!error && hasValidConfig()) {
142     // Calculate the resource directory for LLDB.
143     llvm::SmallString<256> resource_dir;
144     llvm::sys::path::append(resource_dir, GetClangResourceDir().GetPath(),
145                             "include");
146     m_resource_inc = std::string(resource_dir.str());
147 
148     // This order matches the way Clang orders these directories.
149     m_include_dirs = {m_std_inc.Get().str(), m_resource_inc,
150                       m_c_inc.Get().str()};
151     if (m_c_target_inc.Valid())
152       m_include_dirs.push_back(m_c_target_inc.Get().str());
153     if (m_std_target_inc.Valid())
154       m_include_dirs.push_back(m_std_target_inc.Get().str());
155     m_imported_modules = {"std"};
156   }
157 }
158