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 const std::string &CIndexer::getClangResourcesPath() {
100   // Did we already compute the path?
101   if (!ResourcesPath.empty())
102     return ResourcesPath;
103 
104   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   Dl_info info;
129   std::string Path;
130   // This silly cast below avoids a C++ warning.
131   if (dladdr((void *)(uintptr_t)clang_createTranslationUnit, &info) != 0) {
132     // We now have the CIndex directory, locate clang relative to it.
133     LibClangPath += info.dli_fname;
134   } else if (!(Path = llvm::sys::fs::getMainExecutable(nullptr, nullptr)).empty()) {
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     LibClangPath += Path;
139   } else {
140     // It's rather unlikely we end up here. But it could happen, so report an
141     // error instead of crashing.
142     llvm::report_fatal_error("could not locate Clang resource path");
143   }
144 
145 #endif
146 
147   // Cache our result.
148   ResourcesPath = driver::Driver::GetResourcesPath(LibClangPath);
149   return ResourcesPath;
150 }
151 
152 StringRef CIndexer::getClangToolchainPath() {
153   if (!ToolchainPath.empty())
154     return ToolchainPath;
155   StringRef ResourcePath = getClangResourcesPath();
156   ToolchainPath =
157       std::string(llvm::sys::path::parent_path(llvm::sys::path::parent_path(
158           llvm::sys::path::parent_path(ResourcePath))));
159   return ToolchainPath;
160 }
161 
162 LibclangInvocationReporter::LibclangInvocationReporter(
163     CIndexer &Idx, OperationKind Op, unsigned ParseOptions,
164     llvm::ArrayRef<const char *> Args,
165     llvm::ArrayRef<std::string> InvocationArgs,
166     llvm::ArrayRef<CXUnsavedFile> UnsavedFiles) {
167   StringRef Path = Idx.getInvocationEmissionPath();
168   if (Path.empty())
169     return;
170 
171   // Create a temporary file for the invocation log.
172   SmallString<256> TempPath;
173   TempPath = Path;
174   llvm::sys::path::append(TempPath, "libclang-%%%%%%%%%%%%");
175   int FD;
176   if (llvm::sys::fs::createUniqueFile(TempPath, FD, TempPath,
177                                       llvm::sys::fs::OF_Text))
178     return;
179   File = static_cast<std::string>(TempPath);
180   llvm::raw_fd_ostream OS(FD, /*ShouldClose=*/true);
181 
182   // Write out the information about the invocation to it.
183   auto WriteStringKey = [&OS](StringRef Key, StringRef Value) {
184     OS << R"(")" << Key << R"(":")";
185     OS << llvm::yaml::escape(Value) << '"';
186   };
187   OS << '{';
188   WriteStringKey("toolchain", Idx.getClangToolchainPath());
189   OS << ',';
190   WriteStringKey("libclang.operation",
191                  Op == OperationKind::ParseOperation ? "parse" : "complete");
192   OS << ',';
193   OS << R"("libclang.opts":)" << ParseOptions;
194   OS << ',';
195   OS << R"("args":[)";
196   for (const auto &I : llvm::enumerate(Args)) {
197     if (I.index())
198       OS << ',';
199     OS << '"' << llvm::yaml::escape(I.value()) << '"';
200   }
201   if (!InvocationArgs.empty()) {
202     OS << R"(],"invocation-args":[)";
203     for (const auto &I : llvm::enumerate(InvocationArgs)) {
204       if (I.index())
205         OS << ',';
206       OS << '"' << llvm::yaml::escape(I.value()) << '"';
207     }
208   }
209   if (!UnsavedFiles.empty()) {
210     OS << R"(],"unsaved_file_hashes":[)";
211     for (const auto &UF : llvm::enumerate(UnsavedFiles)) {
212       if (UF.index())
213         OS << ',';
214       OS << '{';
215       WriteStringKey("name", UF.value().Filename);
216       OS << ',';
217       llvm::MD5 Hash;
218       Hash.update(getContents(UF.value()));
219       llvm::MD5::MD5Result Result;
220       Hash.final(Result);
221       SmallString<32> Digest = Result.digest();
222       WriteStringKey("md5", Digest);
223       OS << '}';
224     }
225   }
226   OS << "]}";
227 }
228 
229 LibclangInvocationReporter::~LibclangInvocationReporter() {
230   if (!File.empty())
231     llvm::sys::fs::remove(File);
232 }
233