[Support] Rename HashBuilderImpl to HashBuilder (NFC) #68173

kazutakahirata · 2023-10-04T03:52:26Z

Commit 9370271 made HashBuilder an
alias for HashBuilderImpl:

template <class HasherT, support::endianness Endianness>
using HashBuilder = HashBuilderImpl<HasherT, Endianness>;

This patch renames HashBuilderImpl to HashBuilder while removing the
alias above.

Commit 9370271 made HashBuilder an alias for HashBuilderImpl: template <class HasherT, support::endianness Endianness> using HashBuilder = HashBuilderImpl<HasherT, Endianness>; This patch renames HashBuilderImpl to HashBuilder while removing the alias above.

llvmbot · 2023-10-04T03:58:31Z

@llvm/pr-subscribers-llvm-support
@llvm/pr-subscribers-llvm-adt
@llvm/pr-subscribers-clang-modules

@llvm/pr-subscribers-clang

Changes

Commit 9370271 made HashBuilder an
alias for HashBuilderImpl:

template <class HasherT, support::endianness Endianness>
using HashBuilder = HashBuilderImpl<HasherT, Endianness>;

This patch renames HashBuilderImpl to HashBuilder while removing the
alias above.

Patch is 20.37 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/68173.diff

8 Files Affected:

(modified) clang/include/clang/Basic/ObjCRuntime.h (+1-1)
(modified) clang/include/clang/Basic/Sanitizers.h (+1-1)
(modified) clang/include/clang/Lex/HeaderSearchOptions.h (+2-2)
(modified) clang/include/clang/Serialization/ModuleFileExtension.h (+1-2)
(modified) llvm/include/llvm/Support/HashBuilder.h (+73-81)
(modified) llvm/include/llvm/Support/VersionTuple.h (+2-3)
(modified) llvm/unittests/ADT/HashingTest.cpp (+2-2)
(modified) llvm/unittests/Support/HashBuilderTest.cpp (+4-4)

diff --git a/clang/include/clang/Basic/ObjCRuntime.h b/clang/include/clang/Basic/ObjCRuntime.h
index 0f714ed3ad603a5..d783154c3f9f135 100644
--- a/clang/include/clang/Basic/ObjCRuntime.h
+++ b/clang/include/clang/Basic/ObjCRuntime.h
@@ -483,7 +483,7 @@ class ObjCRuntime {
   }
 
   template <typename HasherT, llvm::support::endianness Endianness>
-  friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
+  friend void addHash(llvm::HashBuilder<HasherT, Endianness> &HBuilder,
                       const ObjCRuntime &OCR) {
     HBuilder.add(OCR.getKind(), OCR.getVersion());
   }
diff --git a/clang/include/clang/Basic/Sanitizers.h b/clang/include/clang/Basic/Sanitizers.h
index 4659e45c7883419..090a3a7fa907625 100644
--- a/clang/include/clang/Basic/Sanitizers.h
+++ b/clang/include/clang/Basic/Sanitizers.h
@@ -78,7 +78,7 @@ class SanitizerMask {
   llvm::hash_code hash_value() const;
 
   template <typename HasherT, llvm::support::endianness Endianness>
-  friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
+  friend void addHash(llvm::HashBuilder<HasherT, Endianness> &HBuilder,
                       const SanitizerMask &SM) {
     HBuilder.addRange(&SM.maskLoToHigh[0], &SM.maskLoToHigh[kNumElem]);
   }
diff --git a/clang/include/clang/Lex/HeaderSearchOptions.h b/clang/include/clang/Lex/HeaderSearchOptions.h
index 126659f3ac00223..206bc69d7b2cdcb 100644
--- a/clang/include/clang/Lex/HeaderSearchOptions.h
+++ b/clang/include/clang/Lex/HeaderSearchOptions.h
@@ -268,7 +268,7 @@ inline llvm::hash_code hash_value(const HeaderSearchOptions::Entry &E) {
 }
 
 template <typename HasherT, llvm::support::endianness Endianness>
-inline void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
+inline void addHash(llvm::HashBuilder<HasherT, Endianness> &HBuilder,
                     const HeaderSearchOptions::Entry &E) {
   HBuilder.add(E.Path, E.Group, E.IsFramework, E.IgnoreSysRoot);
 }
@@ -279,7 +279,7 @@ hash_value(const HeaderSearchOptions::SystemHeaderPrefix &SHP) {
 }
 
 template <typename HasherT, llvm::support::endianness Endianness>
-inline void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
+inline void addHash(llvm::HashBuilder<HasherT, Endianness> &HBuilder,
                     const HeaderSearchOptions::SystemHeaderPrefix &SHP) {
   HBuilder.add(SHP.Prefix, SHP.IsSystemHeader);
 }
diff --git a/clang/include/clang/Serialization/ModuleFileExtension.h b/clang/include/clang/Serialization/ModuleFileExtension.h
index 2168ce2ce607c08..528e0aeed2fb341 100644
--- a/clang/include/clang/Serialization/ModuleFileExtension.h
+++ b/clang/include/clang/Serialization/ModuleFileExtension.h
@@ -86,8 +86,7 @@ class ModuleFileExtension
   /// The default implementation of this function simply does nothing, so the
   /// presence/absence of this extension does not distinguish module files.
   using ExtensionHashBuilder =
-      llvm::HashBuilderImpl<llvm::MD5,
-                            llvm::support::endian::system_endianness()>;
+      llvm::HashBuilder<llvm::MD5, llvm::support::endian::system_endianness()>;
   virtual void hashExtension(ExtensionHashBuilder &HBuilder) const;
 
   /// Create a new module file extension writer, which will be
diff --git a/llvm/include/llvm/Support/HashBuilder.h b/llvm/include/llvm/Support/HashBuilder.h
index c3fa011b6aa7e9c..91738b63912a637 100644
--- a/llvm/include/llvm/Support/HashBuilder.h
+++ b/llvm/include/llvm/Support/HashBuilder.h
@@ -85,20 +85,67 @@ template <typename HasherT> class HashBuilderBase {
   HasherT &Hasher;
 };
 
-/// Implementation of the `HashBuilder` interface.
+/// Interface to help hash various types through a hasher type.
+///
+/// Via provided specializations of `add`, `addRange`, and `addRangeElements`
+/// functions, various types (e.g. `ArrayRef`, `StringRef`, etc.) can be hashed
+/// without requiring any knowledge of hashed types from the hasher type.
+///
+/// The only method expected from the templated hasher type `HasherT` is:
+/// * void update(ArrayRef<uint8_t> Data)
+///
+/// Additionally, the following methods will be forwarded to the hasher type:
+/// * decltype(std::declval<HasherT &>().final()) final()
+/// * decltype(std::declval<HasherT &>().result()) result()
+///
+/// From a user point of view, the interface provides the following:
+/// * `template<typename T> add(const T &Value)`
+///   The `add` function implements hashing of various types.
+/// * `template <typename ItT> void addRange(ItT First, ItT Last)`
+///   The `addRange` function is designed to aid hashing a range of values.
+///   It explicitly adds the size of the range in the hash.
+/// * `template <typename ItT> void addRangeElements(ItT First, ItT Last)`
+///   The `addRangeElements` function is also designed to aid hashing a range of
+///   values. In contrast to `addRange`, it **ignores** the size of the range,
+///   behaving as if elements were added one at a time with `add`.
+///
+/// User-defined `struct` types can participate in this interface by providing
+/// an `addHash` templated function. See the associated template specialization
+/// for details.
+///
+/// This interface does not impose requirements on the hasher
+/// `update(ArrayRef<uint8_t> Data)` method. We want to avoid collisions for
+/// variable-size types; for example for
+/// ```
+/// builder.add({1});
+/// builder.add({2, 3});
+/// ```
+/// and
+/// ```
+/// builder.add({1, 2});
+/// builder.add({3});
+/// ```
+/// . Thus, specializations of `add` and `addHash` for variable-size types must
+/// not assume that the hasher type considers the size as part of the hash; they
+/// must explicitly add the size to the hash. See for example specializations
+/// for `ArrayRef` and `StringRef`.
+///
+/// Additionally, since types are eventually forwarded to the hasher's
+/// `void update(ArrayRef<uint8_t>)` method, endianness plays a role in the hash
+/// computation (for example when computing `add((int)123)`).
+/// Specifiying a non-`native` `Endianness` template parameter allows to compute
+/// stable hash across platforms with different endianness.
 template <typename HasherT, support::endianness Endianness>
-class HashBuilderImpl : public HashBuilderBase<HasherT> {
+class HashBuilder : public HashBuilderBase<HasherT> {
 public:
-  explicit HashBuilderImpl(HasherT &Hasher)
-      : HashBuilderBase<HasherT>(Hasher) {}
+  explicit HashBuilder(HasherT &Hasher) : HashBuilderBase<HasherT>(Hasher) {}
   template <typename... ArgTypes>
-  explicit HashBuilderImpl(ArgTypes &&...Args)
+  explicit HashBuilder(ArgTypes &&...Args)
       : HashBuilderBase<HasherT>(Args...) {}
 
   /// Implement hashing for hashable data types, e.g. integral or enum values.
   template <typename T>
-  std::enable_if_t<hashbuilder_detail::IsHashableData<T>::value,
-                   HashBuilderImpl &>
+  std::enable_if_t<hashbuilder_detail::IsHashableData<T>::value, HashBuilder &>
   add(T Value) {
     return adjustForEndiannessAndAdd(Value);
   }
@@ -116,7 +163,7 @@ class HashBuilderImpl : public HashBuilderBase<HasherT> {
   /// builder.add({3});
   /// ```
   /// do not collide.
-  template <typename T> HashBuilderImpl &add(ArrayRef<T> Value) {
+  template <typename T> HashBuilder &add(ArrayRef<T> Value) {
     // As of implementation time, simply calling `addRange(Value)` would also go
     // through the `update` fast path. But that would rely on the implementation
     // details of `ArrayRef::begin()` and `ArrayRef::end()`. Explicitly call
@@ -146,7 +193,7 @@ class HashBuilderImpl : public HashBuilderBase<HasherT> {
   /// builder.add("c");
   /// ```
   /// do not collide.
-  HashBuilderImpl &add(StringRef Value) {
+  HashBuilder &add(StringRef Value) {
     // As of implementation time, simply calling `addRange(Value)` would also go
     // through `update`. But that would rely on the implementation of
     // `StringRef::begin()` and `StringRef::end()`. Explicitly call `update` to
@@ -159,7 +206,7 @@ class HashBuilderImpl : public HashBuilderBase<HasherT> {
 
   template <typename T>
   using HasAddHashT =
-      decltype(addHash(std::declval<HashBuilderImpl &>(), std::declval<T &>()));
+      decltype(addHash(std::declval<HashBuilder &>(), std::declval<T &>()));
   /// Implement hashing for user-defined `struct`s.
   ///
   /// Any user-define `struct` can participate in hashing via `HashBuilder` by
@@ -179,7 +226,7 @@ class HashBuilderImpl : public HashBuilderBase<HasherT> {
   /// };
   ///
   /// template <typename HasherT, support::endianness Endianness>
-  /// void addHash(HashBuilderImpl<HasherT, Endianness> &HBuilder,
+  /// void addHash(HashBuilder<HasherT, Endianness> &HBuilder,
   ///              const SimpleStruct &Value) {
   ///   HBuilder.add(Value.c);
   ///   HBuilder.add(Value.i);
@@ -199,7 +246,7 @@ class HashBuilderImpl : public HashBuilderBase<HasherT> {
   ///   // If possible, we want to hash both `I` and `C` in a single
   ///   // `update` call for performance concerns.
   ///   template <typename HasherT, support::endianness Endianness>
-  ///   friend void addHash(HashBuilderImpl<HasherT, Endianness> &HBuilder,
+  ///   friend void addHash(HashBuilder<HasherT, Endianness> &HBuilder,
   ///                       const StructWithFastHash &Value) {
   ///     if (Endianness == support::endian::system_endianness()) {
   ///       HBuilder.update(ArrayRef(
@@ -229,7 +276,7 @@ class HashBuilderImpl : public HashBuilderBase<HasherT> {
   ///       Elements[I] = I;
   ///   }
   ///   template <typename HasherT, support::endianness Endianness>
-  ///   friend void addHash(HashBuilderImpl<HasherT, Endianness> &HBuilder,
+  ///   friend void addHash(HashBuilder<HasherT, Endianness> &HBuilder,
   ///                       const CustomContainer &Value) {
   ///     if (Endianness == support::endian::system_endianness()) {
   ///       HBuilder.update(ArrayRef(
@@ -246,18 +293,18 @@ class HashBuilderImpl : public HashBuilderBase<HasherT> {
   template <typename T>
   std::enable_if_t<is_detected<HasAddHashT, T>::value &&
                        !hashbuilder_detail::IsHashableData<T>::value,
-                   HashBuilderImpl &>
+                   HashBuilder &>
   add(const T &Value) {
     addHash(*this, Value);
     return *this;
   }
 
   template <typename T1, typename T2>
-  HashBuilderImpl &add(const std::pair<T1, T2> &Value) {
+  HashBuilder &add(const std::pair<T1, T2> &Value) {
     return add(Value.first, Value.second);
   }
 
-  template <typename... Ts> HashBuilderImpl &add(const std::tuple<Ts...> &Arg) {
+  template <typename... Ts> HashBuilder &add(const std::tuple<Ts...> &Arg) {
     std::apply([this](const auto &...Args) { this->add(Args...); }, Arg);
     return *this;
   }
@@ -273,31 +320,29 @@ class HashBuilderImpl : public HashBuilderBase<HasherT> {
   /// add(Arg2)
   /// ```
   template <typename... Ts>
-  std::enable_if_t<(sizeof...(Ts) > 1), HashBuilderImpl &>
-  add(const Ts &...Args) {
+  std::enable_if_t<(sizeof...(Ts) > 1), HashBuilder &> add(const Ts &...Args) {
     return (add(Args), ...);
   }
 
   template <typename ForwardIteratorT>
-  HashBuilderImpl &addRange(ForwardIteratorT First, ForwardIteratorT Last) {
+  HashBuilder &addRange(ForwardIteratorT First, ForwardIteratorT Last) {
     add(std::distance(First, Last));
     return addRangeElements(First, Last);
   }
 
-  template <typename RangeT> HashBuilderImpl &addRange(const RangeT &Range) {
+  template <typename RangeT> HashBuilder &addRange(const RangeT &Range) {
     return addRange(adl_begin(Range), adl_end(Range));
   }
 
   template <typename ForwardIteratorT>
-  HashBuilderImpl &addRangeElements(ForwardIteratorT First,
-                                    ForwardIteratorT Last) {
+  HashBuilder &addRangeElements(ForwardIteratorT First, ForwardIteratorT Last) {
     return addRangeElementsImpl(
         First, Last,
         typename std::iterator_traits<ForwardIteratorT>::iterator_category());
   }
 
   template <typename RangeT>
-  HashBuilderImpl &addRangeElements(const RangeT &Range) {
+  HashBuilder &addRangeElements(const RangeT &Range) {
     return addRangeElements(adl_begin(Range), adl_end(Range));
   }
 
@@ -306,7 +351,7 @@ class HashBuilderImpl : public HashBuilderBase<HasherT> {
       std::declval<T &>(), support::endianness::little));
   /// Adjust `Value` for the target endianness and add it to the hash.
   template <typename T>
-  std::enable_if_t<is_detected<HasByteSwapT, T>::value, HashBuilderImpl &>
+  std::enable_if_t<is_detected<HasByteSwapT, T>::value, HashBuilder &>
   adjustForEndiannessAndAdd(const T &Value) {
     T SwappedValue = support::endian::byte_swap(Value, Endianness);
     this->update(ArrayRef(reinterpret_cast<const uint8_t *>(&SwappedValue),
@@ -318,9 +363,9 @@ class HashBuilderImpl : public HashBuilderBase<HasherT> {
   // FIXME: Once available, specialize this function for `contiguous_iterator`s,
   // and use it for `ArrayRef` and `StringRef`.
   template <typename ForwardIteratorT>
-  HashBuilderImpl &addRangeElementsImpl(ForwardIteratorT First,
-                                        ForwardIteratorT Last,
-                                        std::forward_iterator_tag) {
+  HashBuilder &addRangeElementsImpl(ForwardIteratorT First,
+                                    ForwardIteratorT Last,
+                                    std::forward_iterator_tag) {
     for (auto It = First; It != Last; ++It)
       add(*It);
     return *this;
@@ -329,7 +374,7 @@ class HashBuilderImpl : public HashBuilderBase<HasherT> {
   template <typename T>
   std::enable_if_t<hashbuilder_detail::IsHashableData<T>::value &&
                        Endianness == support::endian::system_endianness(),
-                   HashBuilderImpl &>
+                   HashBuilder &>
   addRangeElementsImpl(T *First, T *Last, std::forward_iterator_tag) {
     this->update(ArrayRef(reinterpret_cast<const uint8_t *>(First),
                           (Last - First) * sizeof(T)));
@@ -337,59 +382,6 @@ class HashBuilderImpl : public HashBuilderBase<HasherT> {
   }
 };
 
-/// Interface to help hash various types through a hasher type.
-///
-/// Via provided specializations of `add`, `addRange`, and `addRangeElements`
-/// functions, various types (e.g. `ArrayRef`, `StringRef`, etc.) can be hashed
-/// without requiring any knowledge of hashed types from the hasher type.
-///
-/// The only method expected from the templated hasher type `HasherT` is:
-/// * void update(ArrayRef<uint8_t> Data)
-///
-/// Additionally, the following methods will be forwarded to the hasher type:
-/// * decltype(std::declval<HasherT &>().final()) final()
-/// * decltype(std::declval<HasherT &>().result()) result()
-///
-/// From a user point of view, the interface provides the following:
-/// * `template<typename T> add(const T &Value)`
-///   The `add` function implements hashing of various types.
-/// * `template <typename ItT> void addRange(ItT First, ItT Last)`
-///   The `addRange` function is designed to aid hashing a range of values.
-///   It explicitly adds the size of the range in the hash.
-/// * `template <typename ItT> void addRangeElements(ItT First, ItT Last)`
-///   The `addRangeElements` function is also designed to aid hashing a range of
-///   values. In contrast to `addRange`, it **ignores** the size of the range,
-///   behaving as if elements were added one at a time with `add`.
-///
-/// User-defined `struct` types can participate in this interface by providing
-/// an `addHash` templated function. See the associated template specialization
-/// for details.
-///
-/// This interface does not impose requirements on the hasher
-/// `update(ArrayRef<uint8_t> Data)` method. We want to avoid collisions for
-/// variable-size types; for example for
-/// ```
-/// builder.add({1});
-/// builder.add({2, 3});
-/// ```
-/// and
-/// ```
-/// builder.add({1, 2});
-/// builder.add({3});
-/// ```
-/// . Thus, specializations of `add` and `addHash` for variable-size types must
-/// not assume that the hasher type considers the size as part of the hash; they
-/// must explicitly add the size to the hash. See for example specializations
-/// for `ArrayRef` and `StringRef`.
-///
-/// Additionally, since types are eventually forwarded to the hasher's
-/// `void update(ArrayRef<uint8_t>)` method, endianness plays a role in the hash
-/// computation (for example when computing `add((int)123)`).
-/// Specifiying a non-`native` `Endianness` template parameter allows to compute
-/// stable hash across platforms with different endianness.
-template <class HasherT, support::endianness Endianness>
-using HashBuilder = HashBuilderImpl<HasherT, Endianness>;
-
 namespace hashbuilder_detail {
 class HashCodeHasher {
 public:
diff --git a/llvm/include/llvm/Support/VersionTuple.h b/llvm/include/llvm/Support/VersionTuple.h
index 828a6db54708dfa..b85500e20d1bdd3 100644
--- a/llvm/include/llvm/Support/VersionTuple.h
+++ b/llvm/include/llvm/Support/VersionTuple.h
@@ -22,8 +22,7 @@
 #include <tuple>
 
 namespace llvm {
-template <typename HasherT, support::endianness Endianness>
-class HashBuilderImpl;
+template <typename HasherT, support::endianness Endianness> class HashBuilder;
 class raw_ostream;
 class StringRef;
 
@@ -175,7 +174,7 @@ class VersionTuple {
   }
 
   template <typename HasherT, llvm::support::endianness Endianness>
-  friend void addHash(HashBuilderImpl<HasherT, Endianness> &HBuilder,
+  friend void addHash(HashBuilder<HasherT, Endianness> &HBuilder,
                       const VersionTuple &VT) {
     HBuilder.add(VT.Major, VT.Minor, VT.Subminor, VT.Build);
   }
diff --git a/llvm/unittests/ADT/HashingTest.cpp b/llvm/unittests/ADT/HashingTest.cpp
index 01a8a962b8e2e33..d175f8afee34a45 100644
--- a/llvm/unittests/ADT/HashingTest.cpp
+++ b/llvm/unittests/ADT/HashingTest.cpp
@@ -425,7 +425,7 @@ struct StructWithHashBuilderSupport {
   char C;
   int I;
   template <typename HasherT, llvm::support::endianness Endianness>
-  friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
+  friend void addHash(llvm::HashBuilder<HasherT, Endianness> &HBuilder,
                       const StructWithHashBuilderSupport &Value) {
     HBuilder.add(Value.C, Value.I);
   }
@@ -440,7 +440,7 @@ struct StructWithHashBuilderAndHashValueSupport {
   char C;
   int I;
   template <typename HasherT, llvm::support::endianness Endianness>
-  friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
+  friend void addHash(llvm::HashBuilder<HasherT, Endianness> &HBuilder,
                       const StructWithHashBuilderAndHashValueSupport &Value) {}
   friend hash_code
   hash_value(const StructWithHashBuilderAndHashValueSupport &Value) {
diff --git a/llvm/unittests/Support/HashBuilderTest.cpp b/llvm/unittests/Support/HashBuilderTest.cpp
index 65d5146555d47df..ba913f5f0108f89 100644
--- a/llvm/unittests/Support/HashBuilderTest.cpp
+++ b/llvm/unittests/Support/HashBuilderTest.cpp
@@ -125,7 +125,7 @@ struct SimpleStruct {
 };
 
 template <typename HasherT, llvm::support::endianness Endianness>
-void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
+void addHash(llvm::HashBuilder<HasherT, Endianness> &HBuilder,
              const SimpleStruct &Value) {
   HBuilder.add(Value.C);
   HBuilder.add(Value.I);
@@ -139,7 +139,7 @@ struct StructWithoutCopyOrMove {
   StructWithoutCopyOrMove &operator=(const StructWithoutCopyOrMove &) = delete;
 
   template <typename HasherT, llvm::support::endianness Endianness>
-  friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
+  friend void addHash(llvm::HashBuilder<HasherT, Endianness> &HBuilder,
                       const StructWithoutCopyOrMove &Value) {
     HBuilder.add(Value.I);
   }
@@ -154,7 +154,7 @@ struct /* __attribute__((packed)) */ StructWithFastHash {
   // If possible, we want to hash both `I` and `C` in a single `update`
   // call for performance concerns.
   template <typename HasherT, llvm::support::endianness Endianness>
-  friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
+  friend void addHash(llvm::HashBuilder<HasherT, Endianness> &HBuilder,
                       const StructWithFastHash &Value) {
     if (Endianness == llvm::support::endian::system_endianness()) {
       HBuilder.update(llvm::ArrayRef(reinterpret_cast<const uint8_t *>(&Value),
@@ -178,7 +178,7 @@ struct CustomContainer {
       Elements[I] = I;
   }
   templ...
[truncated]

kazutakahirata requested review from kuhar, zero9178 and dwblaikie October 4, 2023 03:53

llvmbot added clang Clang issues not falling into any other category clang:frontend Language frontend issues, e.g. anything involving "Sema" clang:modules C++20 modules and Clang Header Modules llvm:support llvm:adt labels Oct 4, 2023

zero9178 approved these changes Oct 4, 2023

View reviewed changes

kazutakahirata merged commit f37028c into llvm:main Oct 5, 2023
8 checks passed

kazutakahirata deleted the pr_endian_HashBuilder branch October 5, 2023 03:33

stepthomas mentioned this pull request Oct 10, 2023

AMDGPU stepthomas atomic csub no rtn forms ver2 stepthomas/llvm-project#1

Closed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[Support] Rename HashBuilderImpl to HashBuilder (NFC) #68173

[Support] Rename HashBuilderImpl to HashBuilder (NFC) #68173

kazutakahirata commented Oct 4, 2023

llvmbot commented Oct 4, 2023 •

edited

[Support] Rename HashBuilderImpl to HashBuilder (NFC) #68173

[Support] Rename HashBuilderImpl to HashBuilder (NFC) #68173

Conversation

kazutakahirata commented Oct 4, 2023

llvmbot commented Oct 4, 2023 • edited

llvmbot commented Oct 4, 2023 •

edited