merge main into amd-staging (llvm#4139)

Author: z1-cciauto

.github/workflows/pr-code-lint.yml

@@ -10,6 +10,7 @@ on:
       - 'users/**'
     paths:
       - 'clang-tools-extra/clang-tidy/**'
+      - '.github/workflows/pr-code-lint.yml'
 
 jobs:
   code_linter:

clang-tools-extra/clangd/FeatureModule.cpp

@@ -22,6 +22,10 @@ FeatureModule::Facilities &FeatureModule::facilities() {
   return *Fac;
 }
 
+void FeatureModuleSet::add(std::unique_ptr<FeatureModule> M) {
+  Modules.push_back(std::move(M));
+}
+
 bool FeatureModuleSet::addImpl(void *Key, std::unique_ptr<FeatureModule> M,
                                const char *Source) {
   if (!Map.try_emplace(Key, M.get()).second) {
@@ -33,5 +37,16 @@ bool FeatureModuleSet::addImpl(void *Key, std::unique_ptr<FeatureModule> M,
   return true;
 }
 
+FeatureModuleSet FeatureModuleSet::fromRegistry() {
+  FeatureModuleSet ModuleSet;
+  for (FeatureModuleRegistry::entry E : FeatureModuleRegistry::entries()) {
+    vlog("Adding feature module '{0}' ({1})", E.getName(), E.getDesc());
+    ModuleSet.add(E.instantiate());
+  }
+  return ModuleSet;
+}
+
 } // namespace clangd
 } // namespace clang
+
+LLVM_INSTANTIATE_REGISTRY(clang::clangd::FeatureModuleRegistry)

clang-tools-extra/clangd/FeatureModule.h

@@ -15,6 +15,7 @@
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/JSON.h"
+#include "llvm/Support/Registry.h"
 #include <memory>
 #include <optional>
 #include <type_traits>
@@ -143,9 +144,14 @@ class FeatureModule {
 
 /// A FeatureModuleSet is a collection of feature modules installed in clangd.
 ///
-/// Modules can be looked up by type, or used via the FeatureModule interface.
-/// This allows individual modules to expose a public API.
-/// For this reason, there can be only one feature module of each type.
+/// Modules added with explicit type specification can be looked up by type, or
+/// used via the FeatureModule interface. This allows individual modules to
+/// expose a public API. For this reason, there can be only one feature module
+/// of each type.
+///
+/// Modules added using a base class pointer can be used only via the
+/// FeatureModule interface and can't be looked up by type, thus custom public
+/// API (if provided by the module) can't be used.
 ///
 /// The set owns the modules. It is itself owned by main, not ClangdServer.
 class FeatureModuleSet {
@@ -164,6 +170,8 @@ class FeatureModuleSet {
 public:
   FeatureModuleSet() = default;
 
+  static FeatureModuleSet fromRegistry();
+
   using iterator = llvm::pointee_iterator<decltype(Modules)::iterator>;
   using const_iterator =
       llvm::pointee_iterator<decltype(Modules)::const_iterator>;
@@ -172,6 +180,7 @@ class FeatureModuleSet {
   const_iterator begin() const { return const_iterator(Modules.begin()); }
   const_iterator end() const { return const_iterator(Modules.end()); }
 
+  void add(std::unique_ptr<FeatureModule> M);
   template <typename Mod> bool add(std::unique_ptr<Mod> M) {
     return addImpl(&ID<Mod>::Key, std::move(M), LLVM_PRETTY_FUNCTION);
   }
@@ -185,6 +194,13 @@ class FeatureModuleSet {
 
 template <typename Mod> int FeatureModuleSet::ID<Mod>::Key;
 
+using FeatureModuleRegistry = llvm::Registry<FeatureModule>;
+
 } // namespace clangd
 } // namespace clang
+
+namespace llvm {
+extern template class Registry<clang::clangd::FeatureModule>;
+} // namespace llvm
+
 #endif

clang-tools-extra/clangd/tool/ClangdMain.cpp

@@ -13,6 +13,7 @@
 #include "Config.h"
 #include "ConfigProvider.h"
 #include "Feature.h"
+#include "FeatureModule.h"
 #include "IncludeCleaner.h"
 #include "PathMapping.h"
 #include "Protocol.h"
@@ -1017,6 +1018,10 @@ clangd accepts flags on the commandline, and in the CLANGD_FLAGS environment var
                : static_cast<int>(ErrorResultCode::CheckFailed);
   }
 
+  FeatureModuleSet ModuleSet = FeatureModuleSet::fromRegistry();
+  if (ModuleSet.begin() != ModuleSet.end())
+    Opts.FeatureModules = &ModuleSet;
+
   // Initialize and run ClangdLSPServer.
   // Change stdin to binary to not lose \r\n on windows.
   llvm::sys::ChangeStdinToBinary();

clang-tools-extra/clangd/unittests/CMakeLists.txt

@@ -54,6 +54,7 @@ add_unittest(ClangdUnitTests ClangdTests
   DumpASTTests.cpp
   ExpectedTypeTest.cpp
   FeatureModulesTests.cpp
+  FeatureModulesRegistryTests.cpp
   FileDistanceTests.cpp
   FileIndexTests.cpp
   FindSymbolsTests.cpp

clang-tools-extra/clangd/unittests/FeatureModulesRegistryTests.cpp

@@ -0,0 +1,92 @@
+//===--- FeatureModulesRegistryTests.cpp  ---------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "FeatureModule.h"
+#include "refactor/Tweak.h"
+#include "support/Logger.h"
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using testing::ElementsAre;
+
+namespace llvm {
+raw_ostream &operator<<(raw_ostream &OS,
+                        const clang::clangd::FeatureModuleRegistry::entry &E) {
+  OS << "(name = " << E.getName() << ", description = '" << E.getDesc() << "')";
+  return OS;
+}
+
+raw_ostream &operator<<(
+    raw_ostream &OS,
+    const iterator_range<Registry<clang::clangd::FeatureModule>::iterator>
+        &Rng) {
+  OS << "{ ";
+  bool First = true;
+  for (clang::clangd::FeatureModuleRegistry::entry E : Rng) {
+    if (First)
+      First = false;
+    else
+      OS << ", ";
+    OS << E;
+  }
+  OS << " }";
+  return OS;
+}
+
+raw_ostream &operator<<(raw_ostream &OS, const clang::clangd::Tweak &T) {
+  OS << "(id = " << T.id() << ", "
+     << "title = " << T.title() << ")";
+  return OS;
+}
+} // namespace llvm
+
+namespace clang::clangd {
+namespace {
+
+class Dummy final : public FeatureModule {
+  static constexpr const char *TweakID = "DummyTweak";
+  struct DummyTweak final : public Tweak {
+    const char *id() const override { return TweakID; }
+    bool prepare(const Selection &) override { return true; }
+    Expected<Effect> apply(const Selection &) override {
+      return error("not implemented");
+    }
+    std::string title() const override { return id(); }
+    llvm::StringLiteral kind() const override {
+      return llvm::StringLiteral("");
+    };
+  };
+
+  void contributeTweaks(std::vector<std::unique_ptr<Tweak>> &Out) override {
+    Out.emplace_back(new DummyTweak);
+  }
+};
+
+static FeatureModuleRegistry::Add<Dummy>
+    X("dummy", "Dummy feature module with dummy tweak");
+
+MATCHER_P(moduleName, Name, "") { return arg.getName() == Name; }
+MATCHER_P(tweakID, ID, "") { return arg->id() == llvm::StringRef(ID); }
+
+// In this test, it is assumed that for unittests executable, all feature
+// modules are added to the registry only here (in this file). To implement
+// modules for clangd tool, one need to link them directly to the clangd
+// executable in clangd/tool/CMakeLists.txt.
+TEST(FeatureModulesRegistryTest, DummyModule) {
+  EXPECT_THAT(FeatureModuleRegistry::entries(),
+              ElementsAre(moduleName("dummy")));
+  FeatureModuleSet Set = FeatureModuleSet::fromRegistry();
+  ASSERT_EQ(Set.end() - Set.begin(), 1u);
+  std::vector<std::unique_ptr<Tweak>> Tweaks;
+  Set.begin()->contributeTweaks(Tweaks);
+  EXPECT_THAT(Tweaks, ElementsAre(tweakID("DummyTweak")));
+}
+
+} // namespace
+} // namespace clang::clangd

llvm/include/llvm/ADT/Hashing.h

@@ -490,11 +490,8 @@ namespace detail {
 /// recursive combining of arguments used in hash_combine. It is particularly
 /// useful at minimizing the code in the recursive calls to ease the pain
 /// caused by a lack of variadic functions.
-struct hash_combine_helper {
+struct hash_combine_recursive_helper {
   char buffer[64] = {};
-  char *buffer_ptr;
-  char *const buffer_end;
-  size_t length = 0;
   hash_state state;
   const uint64_t seed;
 
@@ -503,17 +500,17 @@ struct hash_combine_helper {
   ///
   /// This sets up the state for a recursive hash combine, including getting
   /// the seed and buffer setup.
-  hash_combine_helper()
-      : buffer_ptr(buffer), buffer_end(buffer + 64),
-        seed(get_execution_seed()) {}
+  hash_combine_recursive_helper()
+    : seed(get_execution_seed()) {}
 
   /// Combine one chunk of data into the current in-flight hash.
   ///
   /// This merges one chunk of data into the hash. First it tries to buffer
   /// the data. If the buffer is full, it hashes the buffer into its
   /// hash_state, empties it, and then merges the new chunk in. This also
   /// handles cases where the data straddles the end of the buffer.
-  template <typename T> void combine_data(T data) {
+  template <typename T>
+  char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
     if (!store_and_advance(buffer_ptr, buffer_end, data)) {
       // Check for skew which prevents the buffer from being packed, and do
       // a partial store into the buffer to fill it. This is only a concern
@@ -544,17 +541,28 @@ struct hash_combine_helper {
                              partial_store_size))
         llvm_unreachable("buffer smaller than stored type");
     }
+    return buffer_ptr;
   }
 
   /// Recursive, variadic combining method.
   ///
   /// This function recurses through each argument, combining that argument
   /// into a single hash.
-  template <typename... Ts> hash_code combine(const Ts &...args) {
-    (combine_data(get_hashable_data(args)), ...);
+  template <typename T, typename ...Ts>
+  hash_code combine(size_t length, char *buffer_ptr, char *buffer_end,
+                    const T &arg, const Ts &...args) {
+    buffer_ptr = combine_data(length, buffer_ptr, buffer_end, get_hashable_data(arg));
 
-    // Finalize the hash by flushing any remaining data in the buffer.
-    //
+    // Recurse to the next argument.
+    return combine(length, buffer_ptr, buffer_end, args...);
+  }
+
+  /// Base case for recursive, variadic combining.
+  ///
+  /// The base case when combining arguments recursively is reached when all
+  /// arguments have been handled. It flushes the remaining buffer and
+  /// constructs a hash_code.
+  hash_code combine(size_t length, char *buffer_ptr, char *buffer_end) {
     // Check whether the entire set of values fit in the buffer. If so, we'll
     // use the optimized short hashing routine and skip state entirely.
     if (length == 0)
@@ -588,10 +596,10 @@ struct hash_combine_helper {
 /// The result is suitable for returning from a user's hash_value
 /// *implementation* for their user-defined type. Consumers of a type should
 /// *not* call this routine, they should instead call 'hash_value'.
-template <typename... Ts> hash_code hash_combine(const Ts &...args) {
+template <typename ...Ts> hash_code hash_combine(const Ts &...args) {
   // Recursively hash each argument using a helper class.
-  ::llvm::hashing::detail::hash_combine_helper helper;
-  return helper.combine(args...);
+  ::llvm::hashing::detail::hash_combine_recursive_helper helper;
+  return helper.combine(0, helper.buffer, helper.buffer + 64, args...);
 }
 
 // Implementation details for implementations of hash_value overloads provided

llvm/lib/CodeGen/GlobalISel/GISelValueTracking.cpp

@@ -675,6 +675,14 @@ void GISelValueTracking::computeKnownBitsImpl(Register R, KnownBits &Known,
     }
     break;
   }
+  case TargetOpcode::G_ABS: {
+    Register SrcReg = MI.getOperand(1).getReg();
+    computeKnownBitsImpl(SrcReg, Known, DemandedElts, Depth + 1);
+    Known = Known.abs();
+    Known.Zero.setHighBits(computeNumSignBits(SrcReg, DemandedElts, Depth + 1) -
+                           1);
+    break;
+  }
   }
 
   LLVM_DEBUG(dumpResult(MI, Known, Depth));

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

@@ -796,18 +796,19 @@ bool FunctionSpecializer::run() {
       if (Count && !ProfcheckDisableMetadataFixes) {
         std::optional<llvm::Function::ProfileCount> MaybeCloneCount =
             Clone->getEntryCount();
-        assert(MaybeCloneCount && "Clone entry count was not set!");
-        uint64_t CallCount = *Count + MaybeCloneCount->getCount();
-        Clone->setEntryCount(CallCount);
-        if (std::optional<llvm::Function::ProfileCount> MaybeOriginalCount =
-                S.F->getEntryCount()) {
-          uint64_t OriginalCount = MaybeOriginalCount->getCount();
-          if (OriginalCount >= *Count) {
-            S.F->setEntryCount(OriginalCount - *Count);
-          } else {
-            // This should generally not happen as that would mean there are
-            // more computed calls to the function than what was recorded.
-            LLVM_DEBUG(S.F->setEntryCount(0));
+        if (MaybeCloneCount) {
+          uint64_t CallCount = *Count + MaybeCloneCount->getCount();
+          Clone->setEntryCount(CallCount);
+          if (std::optional<llvm::Function::ProfileCount> MaybeOriginalCount =
+                  S.F->getEntryCount()) {
+            uint64_t OriginalCount = MaybeOriginalCount->getCount();
+            if (OriginalCount >= *Count) {
+              S.F->setEntryCount(OriginalCount - *Count);
+            } else {
+              // This should generally not happen as that would mean there are
+              // more computed calls to the function than what was recorded.
+              LLVM_DEBUG(S.F->setEntryCount(0));
+            }
           }
         }
       }

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

@@ -5717,8 +5717,11 @@ void LoopVectorizationCostModel::setCostBasedWideningDecision(ElementCount VF) {
       // if the loaded register is involved in an address computation, it is
       // instead changed here when we know this is the case.
       InstWidening Decision = getWideningDecision(I, VF);
-      if (Decision == CM_Widen || Decision == CM_Widen_Reverse)
-        // Scalarize a widened load of address.
+      if (Decision == CM_Widen || Decision == CM_Widen_Reverse ||
+          (!isPredicatedInst(I) && !Legal->isUniformMemOp(*I, VF) &&
+           Decision == CM_Scalarize))
+        // Scalarize a widened load of address or update the cost of a scalar
+        // load of an address.
         setWideningDecision(
             I, VF, CM_Scalarize,
             (VF.getKnownMinValue() *