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