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