LLVM and SPIRV-LLVM-Translator pulldown (WW27) #4006

LLVM: llvm/llvm-project@7c73c2e
SPIRV-LLVM-Translator: KhronosGroup/SPIRV-LLVM-Translator@a84f589

Author: vladimirlaz

.mailmap

@@ -22,6 +22,8 @@
 #
 # Please keep this file sorted.
 
+<[email protected]> <[email protected]>
+<[email protected]> <[email protected]>
 <[email protected]> <[email protected]>
 <[email protected]> <[email protected]>
 <[email protected]> <[email protected]>
@@ -30,3 +32,4 @@ Jon Roelofs <[email protected]> Jon Roelofs <[email protected]>
 Jon Roelofs <[email protected]> Jonathan Roelofs <[email protected]>
 Jon Roelofs <[email protected]> Jonathan Roelofs <[email protected]>
 Martin Storsjö <[email protected]>
+Saleem Abdulrasool <[email protected]> <[email protected]>

clang-tools-extra/clang-tidy/ClangTidyCheck.cpp

@@ -150,11 +150,11 @@ llvm::Optional<int64_t> ClangTidyCheck::OptionsView::getEnumInt(
   unsigned EditDistance = 3;
   for (const auto &NameAndEnum : Mapping) {
     if (IgnoreCase) {
-      if (Value.equals_lower(NameAndEnum.second))
+      if (Value.equals_insensitive(NameAndEnum.second))
         return NameAndEnum.first;
     } else if (Value.equals(NameAndEnum.second)) {
       return NameAndEnum.first;
-    } else if (Value.equals_lower(NameAndEnum.second)) {
+    } else if (Value.equals_insensitive(NameAndEnum.second)) {
       Closest = NameAndEnum.second;
       EditDistance = 0;
       continue;

clang-tools-extra/clang-tidy/altera/KernelNameRestrictionCheck.cpp

@@ -70,9 +70,9 @@ void KernelNameRestrictionPPCallbacks::InclusionDirective(
 
 bool KernelNameRestrictionPPCallbacks::fileNameIsRestricted(
     StringRef FileName) {
-  return FileName.equals_lower("kernel.cl") ||
-         FileName.equals_lower("verilog.cl") ||
-         FileName.equals_lower("vhdl.cl");
+  return FileName.equals_insensitive("kernel.cl") ||
+         FileName.equals_insensitive("verilog.cl") ||
+         FileName.equals_insensitive("vhdl.cl");
 }
 
 void KernelNameRestrictionPPCallbacks::EndOfMainFile() {

clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.cpp

@@ -176,8 +176,8 @@ static bool sameName(StringRef InComment, StringRef InDecl, bool StrictMode) {
     return InComment == InDecl;
   InComment = InComment.trim('_');
   InDecl = InDecl.trim('_');
-  // FIXME: compare_lower only works for ASCII.
-  return InComment.compare_lower(InDecl) == 0;
+  // FIXME: compare_insensitive only works for ASCII.
+  return InComment.compare_insensitive(InDecl) == 0;
 }
 
 static bool looksLikeExpectMethod(const CXXMethodDecl *Expect) {

clang-tools-extra/clang-tidy/cppcoreguidelines/PreferMemberInitializerCheck.cpp

@@ -159,7 +159,7 @@ void PreferMemberInitializerCheck::check(
     if (S->getBeginLoc().isMacroID()) {
       StringRef MacroName = Lexer::getImmediateMacroName(
           S->getBeginLoc(), *Result.SourceManager, getLangOpts());
-      if (MacroName.contains_lower("assert"))
+      if (MacroName.contains_insensitive("assert"))
         return;
     }
     if (isControlStatement(S))

clang-tools-extra/clang-tidy/misc/StaticAssertCheck.cpp

@@ -104,8 +104,8 @@ void StaticAssertCheck::check(const MatchFinder::MatchResult &Result) {
 
     StringRef FalseMacroName =
         Lexer::getImmediateMacroName(FalseLiteralLoc, SM, Opts);
-    if (FalseMacroName.compare_lower("false") == 0 ||
-        FalseMacroName.compare_lower("null") == 0)
+    if (FalseMacroName.compare_insensitive("false") == 0 ||
+        FalseMacroName.compare_insensitive("null") == 0)
       return;
   }
 

clang-tools-extra/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

@@ -93,8 +93,8 @@ bool nameMatch(StringRef L, StringRef R, bool Strict) {
     return L.empty() || R.empty() || L == R;
   // We allow two names if one is a prefix/suffix of the other, ignoring case.
   // Important special case: this is true if either parameter has no name!
-  return L.startswith_lower(R) || R.startswith_lower(L) ||
-         L.endswith_lower(R) || R.endswith_lower(L);
+  return L.startswith_insensitive(R) || R.startswith_insensitive(L) ||
+         L.endswith_insensitive(R) || R.endswith_insensitive(L);
 }
 
 DifferingParamsContainer

clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

@@ -93,7 +93,7 @@ getNewSuffix(llvm::StringRef OldSuffix,
   // Else, find matching suffix, case-*insensitive*ly.
   auto NewSuffix = llvm::find_if(
       NewSuffixes, [OldSuffix](const std::string &PotentialNewSuffix) {
-        return OldSuffix.equals_lower(PotentialNewSuffix);
+        return OldSuffix.equals_insensitive(PotentialNewSuffix);
       });
   // Have a match, return it.
   if (NewSuffix != NewSuffixes.end())

clang-tools-extra/clangd/CodeComplete.cpp

@@ -62,6 +62,7 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
@@ -1679,7 +1680,7 @@ class CodeCompleteFlow {
           C.SemaResult->Kind == CodeCompletionResult::RK_Macro) ||
          (C.IndexResult &&
           C.IndexResult->SymInfo.Kind == index::SymbolKind::Macro)) &&
-        !C.Name.startswith_lower(Filter->pattern()))
+        !C.Name.startswith_insensitive(Filter->pattern()))
       return None;
     return Filter->match(C.Name);
   }
@@ -1910,6 +1911,13 @@ bool isIndexedForCodeCompletion(const NamedDecl &ND, ASTContext &ASTCtx) {
   if (isExplicitTemplateSpecialization(&ND))
     return false;
 
+  // Category decls are not useful on their own outside the interface or
+  // implementation blocks. Moreover, sema already provides completion for
+  // these, even if it requires preamble deserialization. So by excluding them
+  // from the index, we reduce the noise in all the other completion scopes.
+  if (llvm::isa<ObjCCategoryDecl>(&ND) || llvm::isa<ObjCCategoryImplDecl>(&ND))
+    return false;
+
   if (InTopLevelScope(ND))
     return true;
 

clang-tools-extra/clangd/CompileCommands.cpp

@@ -296,9 +296,9 @@ enum DriverMode : unsigned char {
 DriverMode getDriverMode(const std::vector<std::string> &Args) {
   DriverMode Mode = DM_GCC;
   llvm::StringRef Argv0 = Args.front();
-  if (Argv0.endswith_lower(".exe"))
+  if (Argv0.endswith_insensitive(".exe"))
     Argv0 = Argv0.drop_back(strlen(".exe"));
-  if (Argv0.endswith_lower("cl"))
+  if (Argv0.endswith_insensitive("cl"))
     Mode = DM_CL;
   for (const llvm::StringRef Arg : Args) {
     if (Arg == "--driver-mode=cl") {

clang-tools-extra/clangd/ConfigYAML.cpp

@@ -169,7 +169,7 @@ class Parser {
 
   void parse(Fragment::IndexBlock::ExternalBlock &F,
              Located<std::string> ExternalVal) {
-    if (!llvm::StringRef(*ExternalVal).equals_lower("none")) {
+    if (!llvm::StringRef(*ExternalVal).equals_insensitive("none")) {
       error("Only scalar value supported for External is 'None'",
             ExternalVal.Range);
       return;

clang-tools-extra/clangd/HeaderSourceSwitch.cpp

@@ -27,13 +27,13 @@ llvm::Optional<Path> getCorrespondingHeaderOrSource(
   // Lookup in a list of known extensions.
   auto SourceIter =
       llvm::find_if(SourceExtensions, [&PathExt](PathRef SourceExt) {
-        return SourceExt.equals_lower(PathExt);
+        return SourceExt.equals_insensitive(PathExt);
       });
   bool IsSource = SourceIter != std::end(SourceExtensions);
 
   auto HeaderIter =
       llvm::find_if(HeaderExtensions, [&PathExt](PathRef HeaderExt) {
-        return HeaderExt.equals_lower(PathExt);
+        return HeaderExt.equals_insensitive(PathExt);
       });
   bool IsHeader = HeaderIter != std::end(HeaderExtensions);
 

clang-tools-extra/clangd/InlayHints.cpp

@@ -156,7 +156,7 @@ class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
       return false;
 
     StringRef Name = getSimpleName(*Callee);
-    if (!Name.startswith_lower("set"))
+    if (!Name.startswith_insensitive("set"))
       return false;
 
     // In addition to checking that the function has one parameter and its
@@ -168,10 +168,10 @@ class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
     // This currently doesn't handle cases where params use snake_case
     // and functions don't, e.g.
     //   void setExceptionHandler(EHFunc exception_handler);
-    // We could improve this by replacing `equals_lower` with some
+    // We could improve this by replacing `equals_insensitive` with some
     // `sloppy_equals` which ignores case and also skips underscores.
     StringRef WhatItIsSetting = Name.substr(3).ltrim("_");
-    return WhatItIsSetting.equals_lower(ParamNames[0]);
+    return WhatItIsSetting.equals_insensitive(ParamNames[0]);
   }
 
   bool shouldHint(const Expr *Arg, StringRef ParamName) {

clang-tools-extra/clangd/Quality.cpp

@@ -378,7 +378,7 @@ static llvm::Optional<llvm::StringRef>
 wordMatching(llvm::StringRef Name, const llvm::StringSet<> *ContextWords) {
   if (ContextWords)
     for (const auto &Word : ContextWords->keys())
-      if (Name.contains_lower(Word))
+      if (Name.contains_insensitive(Word))
         return Word;
   return llvm::None;
 }
@@ -552,7 +552,7 @@ evaluateDecisionForest(const SymbolQualitySignals &Quality,
   int NumMatch = 0;
   if (Relevance.ContextWords) {
     for (const auto &Word : Relevance.ContextWords->keys()) {
-      if (Relevance.Name.contains_lower(Word)) {
+      if (Relevance.Name.contains_insensitive(Word)) {
         ++NumMatch;
       }
     }

clang-tools-extra/clangd/index/SymbolCollector.cpp

@@ -285,7 +285,8 @@ class SymbolCollector::HeaderFileURICache {
     Line = Line.ltrim();
     if (!Line.startswith("error"))
       return false;
-    return Line.contains_lower("includ"); // Matches "include" or "including".
+    return Line.contains_insensitive(
+        "includ"); // Matches "include" or "including".
   }
 
   // Heuristically headers that only want to be included via an umbrella.

clang-tools-extra/clangd/index/remote/server/Server.cpp

@@ -37,12 +37,18 @@
 #include <grpc++/grpc++.h>
 #include <grpc++/health_check_service_interface.h>
 #include <memory>
+#include <string>
 #include <thread>
+#include <utility>
 
 #if ENABLE_GRPC_REFLECTION
 #include <grpc++/ext/proto_server_reflection_plugin.h>
 #endif
 
+#ifdef __GLIBC__
+#include <malloc.h>
+#endif
+
 namespace clang {
 namespace clangd {
 namespace remote {
@@ -74,6 +80,12 @@ llvm::cl::opt<bool> LogPublic{
     llvm::cl::init(false),
 };
 
+llvm::cl::opt<std::string> LogPrefix{
+    "log-prefix",
+    llvm::cl::desc("A string that'll be prepended to all log statements. "
+                   "Useful when running multiple instances on same host."),
+};
+
 llvm::cl::opt<std::string> TraceFile(
     "trace-file",
     llvm::cl::desc("Path to the file where tracer logs will be stored"));
@@ -354,12 +366,25 @@ class Monitor final : public v1::Monitor::Service {
   std::atomic<llvm::sys::TimePoint<>> IndexBuildTime;
 };
 
+void maybeTrimMemory() {
+#if defined(__GLIBC__) && CLANGD_MALLOC_TRIM
+  malloc_trim(0);
+#endif
+}
+
 // Detect changes in \p IndexPath file and load new versions of the index
 // whenever they become available.
 void hotReload(clangd::SwapIndex &Index, llvm::StringRef IndexPath,
                llvm::vfs::Status &LastStatus,
                llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> &FS,
                Monitor &Monitor) {
+  // glibc malloc doesn't shrink an arena if there are items living at the end,
+  // which might happen since we destroy the old index after building new one.
+  // Trim more aggresively to keep memory usage of the server low.
+  // Note that we do it deliberately here rather than after Index.reset(),
+  // because old index might still be kept alive after the reset call if we are
+  // serving requests.
+  maybeTrimMemory();
   auto Status = FS->status(IndexPath);
   // Requested file is same as loaded index: no reload is needed.
   if (!Status || (Status->getLastModificationTime() ==
@@ -410,27 +435,48 @@ void runServerAndWait(clangd::SymbolIndex &Index, llvm::StringRef ServerAddress,
   ServerShutdownWatcher.join();
 }
 
-std::unique_ptr<Logger> makeLogger(llvm::raw_ostream &OS) {
-  if (!LogPublic)
-    return std::make_unique<StreamLogger>(OS, LogLevel);
-  // Redacted mode:
-  //  - messages outside the scope of a request: log fully
-  //  - messages tagged [public]: log fully
-  //  - errors: log the format string
-  //  - others: drop
-  class RedactedLogger : public StreamLogger {
+std::unique_ptr<Logger> makeLogger(llvm::StringRef LogPrefix,
+                                   llvm::raw_ostream &OS) {
+  std::unique_ptr<Logger> Base;
+  if (LogPublic) {
+    // Redacted mode:
+    //  - messages outside the scope of a request: log fully
+    //  - messages tagged [public]: log fully
+    //  - errors: log the format string
+    //  - others: drop
+    class RedactedLogger : public StreamLogger {
+    public:
+      using StreamLogger::StreamLogger;
+      void log(Level L, const char *Fmt,
+               const llvm::formatv_object_base &Message) override {
+        if (Context::current().get(CurrentRequest) == nullptr ||
+            llvm::StringRef(Fmt).startswith("[public]"))
+          return StreamLogger::log(L, Fmt, Message);
+        if (L >= Error)
+          return StreamLogger::log(L, Fmt,
+                                   llvm::formatv("[redacted] {0}", Fmt));
+      }
+    };
+    Base = std::make_unique<RedactedLogger>(OS, LogLevel);
+  } else {
+    Base = std::make_unique<StreamLogger>(OS, LogLevel);
+  }
+
+  if (LogPrefix.empty())
+    return Base;
+  class PrefixedLogger : public Logger {
+    std::string LogPrefix;
+    std::unique_ptr<Logger> Base;
+
   public:
-    using StreamLogger::StreamLogger;
+    PrefixedLogger(llvm::StringRef LogPrefix, std::unique_ptr<Logger> Base)
+        : LogPrefix(LogPrefix.str()), Base(std::move(Base)) {}
     void log(Level L, const char *Fmt,
              const llvm::formatv_object_base &Message) override {
-      if (Context::current().get(CurrentRequest) == nullptr ||
-          llvm::StringRef(Fmt).startswith("[public]"))
-        return StreamLogger::log(L, Fmt, Message);
-      if (L >= Error)
-        return StreamLogger::log(L, Fmt, llvm::formatv("[redacted] {0}", Fmt));
+      Base->log(L, Fmt, llvm::formatv("[{0}] {1}", LogPrefix, Message));
     }
   };
-  return std::make_unique<RedactedLogger>(OS, LogLevel);
+  return std::make_unique<PrefixedLogger>(LogPrefix, std::move(Base));
 }
 
 } // namespace
@@ -454,7 +500,7 @@ int main(int argc, char *argv[]) {
   llvm::errs().SetBuffered();
   // Don't flush stdout when logging for thread safety.
   llvm::errs().tie(nullptr);
-  auto Logger = makeLogger(llvm::errs());
+  auto Logger = makeLogger(LogPrefix.getValue(), llvm::errs());
   clang::clangd::LoggingSession LoggingSession(*Logger);
 
   llvm::Optional<llvm::raw_fd_ostream> TracerStream;

clang-tools-extra/clangd/support/Path.cpp

@@ -13,7 +13,7 @@ namespace clangd {
 
 #ifdef CLANGD_PATH_CASE_INSENSITIVE
 std::string maybeCaseFoldPath(PathRef Path) { return Path.lower(); }
-bool pathEqual(PathRef A, PathRef B) { return A.equals_lower(B); }
+bool pathEqual(PathRef A, PathRef B) { return A.equals_insensitive(B); }
 #else  // NOT CLANGD_PATH_CASE_INSENSITIVE
 std::string maybeCaseFoldPath(PathRef Path) { return Path.str(); }
 bool pathEqual(PathRef A, PathRef B) { return A == B; }

clang-tools-extra/clangd/test/remote-index/log-prefix.test

@@ -0,0 +1,18 @@
+# RUN: rm -rf %t
+# RUN: clangd-indexer %S/Inputs/Source.cpp > %t.idx
+# RUN: %python %S/pipeline_helper.py --input-file-name=%s --server-arg=--log=verbose --server-arg=-log-prefix=test-prefix --server-log=%t.log --project-root=%S --index-file=%t.idx > /dev/null
+# RUN: FileCheck %s < %t.log
+# REQUIRES: clangd-remote-index
+
+# CHECK: [test-prefix] Server listening on
+{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{},"trace":"off"}}
+---
+{"jsonrpc":"2.0","id":1,"method":"workspace/symbol","params":{"query":"gFoo"}}
+# CHECK: [test-prefix] <<< FuzzyFindRequest
+# CHECK: [test-prefix] >>> FuzzyFindReply
+# CHECK: [test-prefix] [public] request v1/FuzzyFind
+---
+{"jsonrpc":"2.0","id":4,"method":"shutdown"}
+---
+{"jsonrpc":"2.0","method":"exit"}
+