/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/tools/libclang/CIndexer.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===- CIndexer.cpp - Clang-C Source Indexing Library ---------------------===// |
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 | | // This file implements the Clang-C Source Indexing library. |
10 | | // |
11 | | //===----------------------------------------------------------------------===// |
12 | | |
13 | | #include "CIndexer.h" |
14 | | #include "CXString.h" |
15 | | #include "clang/Basic/LLVM.h" |
16 | | #include "clang/Basic/Version.h" |
17 | | #include "clang/Driver/Driver.h" |
18 | | #include "llvm/ADT/STLExtras.h" |
19 | | #include "llvm/ADT/SmallString.h" |
20 | | #include "llvm/Support/FileSystem.h" |
21 | | #include "llvm/Support/MD5.h" |
22 | | #include "llvm/Support/Path.h" |
23 | | #include "llvm/Support/Program.h" |
24 | | #include "llvm/Support/YAMLParser.h" |
25 | | #include <cstdio> |
26 | | #include <mutex> |
27 | | |
28 | | #ifdef __CYGWIN__ |
29 | | #include <cygwin/version.h> |
30 | | #include <sys/cygwin.h> |
31 | | #define _WIN32 1 |
32 | | #endif |
33 | | |
34 | | #ifdef _WIN32 |
35 | | #include <windows.h> |
36 | | #elif defined(_AIX) |
37 | | #include <errno.h> |
38 | | #include <sys/ldr.h> |
39 | | #else |
40 | | #include <dlfcn.h> |
41 | | #endif |
42 | | |
43 | | using namespace clang; |
44 | | |
45 | | #ifdef _AIX |
46 | | namespace clang { |
47 | | namespace { |
48 | | |
49 | | template <typename LibClangPathType> |
50 | | void getClangResourcesPathImplAIX(LibClangPathType &LibClangPath) { |
51 | | int PrevErrno = errno; |
52 | | |
53 | | size_t BufSize = 2048u; |
54 | | std::unique_ptr<char[]> Buf; |
55 | | while (true) { |
56 | | Buf = std::make_unique<char []>(BufSize); |
57 | | errno = 0; |
58 | | int Ret = loadquery(L_GETXINFO, Buf.get(), (unsigned int)BufSize); |
59 | | if (Ret != -1) |
60 | | break; // loadquery() was successful. |
61 | | if (errno != ENOMEM) |
62 | | llvm_unreachable("Encountered an unexpected loadquery() failure"); |
63 | | |
64 | | // errno == ENOMEM; try to allocate more memory. |
65 | | if ((BufSize & ~((-1u) >> 1u)) != 0u) |
66 | | llvm::report_fatal_error("BufSize needed for loadquery() too large"); |
67 | | |
68 | | Buf.release(); |
69 | | BufSize <<= 1u; |
70 | | } |
71 | | |
72 | | // Extract the function entry point from the function descriptor. |
73 | | uint64_t EntryAddr = |
74 | | reinterpret_cast<uintptr_t &>(clang_createTranslationUnit); |
75 | | |
76 | | // Loop to locate the function entry point in the loadquery() results. |
77 | | ld_xinfo *CurInfo = reinterpret_cast<ld_xinfo *>(Buf.get()); |
78 | | while (true) { |
79 | | uint64_t CurTextStart = (uint64_t)CurInfo->ldinfo_textorg; |
80 | | uint64_t CurTextEnd = CurTextStart + CurInfo->ldinfo_textsize; |
81 | | if (CurTextStart <= EntryAddr && EntryAddr < CurTextEnd) |
82 | | break; // Successfully located. |
83 | | |
84 | | if (CurInfo->ldinfo_next == 0u) |
85 | | llvm::report_fatal_error("Cannot locate entry point in " |
86 | | "the loadquery() results"); |
87 | | CurInfo = reinterpret_cast<ld_xinfo *>(reinterpret_cast<char *>(CurInfo) + |
88 | | CurInfo->ldinfo_next); |
89 | | } |
90 | | |
91 | | LibClangPath += reinterpret_cast<char *>(CurInfo) + CurInfo->ldinfo_filename; |
92 | | errno = PrevErrno; |
93 | | } |
94 | | |
95 | | } // end anonymous namespace |
96 | | } // end namespace clang |
97 | | #endif |
98 | | |
99 | 1.04k | const std::string &CIndexer::getClangResourcesPath() { |
100 | | // Did we already compute the path? |
101 | 1.04k | if (!ResourcesPath.empty()) |
102 | 11 | return ResourcesPath; |
103 | | |
104 | 1.02k | SmallString<128> LibClangPath; |
105 | | |
106 | | // Find the location where this library lives (libclang.dylib). |
107 | | #ifdef _WIN32 |
108 | | MEMORY_BASIC_INFORMATION mbi; |
109 | | char path[MAX_PATH]; |
110 | | VirtualQuery((void *)(uintptr_t)clang_createTranslationUnit, &mbi, |
111 | | sizeof(mbi)); |
112 | | GetModuleFileNameA((HINSTANCE)mbi.AllocationBase, path, MAX_PATH); |
113 | | |
114 | | #ifdef __CYGWIN__ |
115 | | char w32path[MAX_PATH]; |
116 | | strcpy(w32path, path); |
117 | | #if CYGWIN_VERSION_API_MAJOR > 0 || CYGWIN_VERSION_API_MINOR >= 181 |
118 | | cygwin_conv_path(CCP_WIN_A_TO_POSIX, w32path, path, MAX_PATH); |
119 | | #else |
120 | | cygwin_conv_to_full_posix_path(w32path, path); |
121 | | #endif |
122 | | #endif |
123 | | |
124 | | LibClangPath += path; |
125 | | #elif defined(_AIX) |
126 | | getClangResourcesPathImplAIX(LibClangPath); |
127 | | #else |
128 | 1.02k | Dl_info info; |
129 | 1.02k | std::string Path; |
130 | | // This silly cast below avoids a C++ warning. |
131 | 1.02k | if (dladdr((void *)(uintptr_t)clang_createTranslationUnit, &info) != 0) { |
132 | | // We now have the CIndex directory, locate clang relative to it. |
133 | 1.02k | LibClangPath += info.dli_fname; |
134 | 1.02k | } else if (0 !(Path = llvm::sys::fs::getMainExecutable(nullptr, nullptr)).empty()0 ) { |
135 | | // If we can't get the path using dladdr, try to get the main executable |
136 | | // path. This may be needed when we're statically linking libclang with |
137 | | // musl libc, for example. |
138 | 0 | LibClangPath += Path; |
139 | 0 | } else { |
140 | | // It's rather unlikely we end up here. But it could happen, so report an |
141 | | // error instead of crashing. |
142 | 0 | llvm::report_fatal_error("could not locate Clang resource path"); |
143 | 0 | } |
144 | | |
145 | 1.02k | #endif |
146 | | |
147 | | // Cache our result. |
148 | 1.02k | ResourcesPath = driver::Driver::GetResourcesPath(LibClangPath); |
149 | 1.02k | return ResourcesPath; |
150 | 1.04k | } |
151 | | |
152 | 9 | StringRef CIndexer::getClangToolchainPath() { |
153 | 9 | if (!ToolchainPath.empty()) |
154 | 2 | return ToolchainPath; |
155 | 7 | StringRef ResourcePath = getClangResourcesPath(); |
156 | 7 | ToolchainPath = |
157 | 7 | std::string(llvm::sys::path::parent_path(llvm::sys::path::parent_path( |
158 | 7 | llvm::sys::path::parent_path(ResourcePath)))); |
159 | 7 | return ToolchainPath; |
160 | 9 | } |
161 | | |
162 | | LibclangInvocationReporter::LibclangInvocationReporter( |
163 | | CIndexer &Idx, OperationKind Op, unsigned ParseOptions, |
164 | | llvm::ArrayRef<const char *> Args, |
165 | | llvm::ArrayRef<std::string> InvocationArgs, |
166 | 1.71k | llvm::ArrayRef<CXUnsavedFile> UnsavedFiles) { |
167 | 1.71k | StringRef Path = Idx.getInvocationEmissionPath(); |
168 | 1.71k | if (Path.empty()) |
169 | 1.70k | return; |
170 | | |
171 | | // Create a temporary file for the invocation log. |
172 | 9 | SmallString<256> TempPath; |
173 | 9 | TempPath = Path; |
174 | 9 | llvm::sys::path::append(TempPath, "libclang-%%%%%%%%%%%%"); |
175 | 9 | int FD; |
176 | 9 | if (llvm::sys::fs::createUniqueFile(TempPath, FD, TempPath, |
177 | 9 | llvm::sys::fs::OF_Text)) |
178 | 0 | return; |
179 | 9 | File = static_cast<std::string>(TempPath); |
180 | 9 | llvm::raw_fd_ostream OS(FD, /*ShouldClose=*/true); |
181 | | |
182 | | // Write out the information about the invocation to it. |
183 | 26 | auto WriteStringKey = [&OS](StringRef Key, StringRef Value) { |
184 | 26 | OS << R"(")" << Key << R"(":")"; |
185 | 26 | OS << llvm::yaml::escape(Value) << '"'; |
186 | 26 | }; |
187 | 9 | OS << '{'; |
188 | 9 | WriteStringKey("toolchain", Idx.getClangToolchainPath()); |
189 | 9 | OS << ','; |
190 | 9 | WriteStringKey("libclang.operation", |
191 | 9 | Op == OperationKind::ParseOperation ? "parse"7 : "complete"2 ); |
192 | 9 | OS << ','; |
193 | 9 | OS << R"("libclang.opts":)" << ParseOptions; |
194 | 9 | OS << ','; |
195 | 9 | OS << R"("args":[)"; |
196 | 55 | for (const auto &I : llvm::enumerate(Args)) { |
197 | 55 | if (I.index()) |
198 | 46 | OS << ','; |
199 | 55 | OS << '"' << llvm::yaml::escape(I.value()) << '"'; |
200 | 55 | } |
201 | 9 | if (!InvocationArgs.empty()) { |
202 | 2 | OS << R"(],"invocation-args":[)"; |
203 | 2 | for (const auto &I : llvm::enumerate(InvocationArgs)) { |
204 | 2 | if (I.index()) |
205 | 0 | OS << ','; |
206 | 2 | OS << '"' << llvm::yaml::escape(I.value()) << '"'; |
207 | 2 | } |
208 | 2 | } |
209 | 9 | if (!UnsavedFiles.empty()) { |
210 | 4 | OS << R"(],"unsaved_file_hashes":[)"; |
211 | 4 | for (const auto &UF : llvm::enumerate(UnsavedFiles)) { |
212 | 4 | if (UF.index()) |
213 | 0 | OS << ','; |
214 | 4 | OS << '{'; |
215 | 4 | WriteStringKey("name", UF.value().Filename); |
216 | 4 | OS << ','; |
217 | 4 | llvm::MD5 Hash; |
218 | 4 | Hash.update(getContents(UF.value())); |
219 | 4 | llvm::MD5::MD5Result Result; |
220 | 4 | Hash.final(Result); |
221 | 4 | SmallString<32> Digest = Result.digest(); |
222 | 4 | WriteStringKey("md5", Digest); |
223 | 4 | OS << '}'; |
224 | 4 | } |
225 | 4 | } |
226 | 9 | OS << "]}"; |
227 | 9 | } |
228 | | |
229 | 1.70k | LibclangInvocationReporter::~LibclangInvocationReporter() { |
230 | 1.70k | if (!File.empty()) |
231 | 3 | llvm::sys::fs::remove(File); |
232 | 1.70k | } |