Coverage Report

Created: 2022-07-16 07:03

/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
}