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
43using namespace clang;
44
45#ifdef _AIX
46namespace clang {
47namespace {
48
49template <typename LibClangPathType>
50void 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
99const 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
152StringRef 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
162LibclangInvocationReporter::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
229LibclangInvocationReporter::~LibclangInvocationReporter() {
230  if (!File.empty())
231    llvm::sys::fs::remove(File);
232}
233