[llvm-branch-commits] [llvm] 1d6ebdf - Switch from llvm::is_trivially_copyable to std::is_trivially_copyable

Fangrui Song via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Wed Dec 2 22:07:53 PST 2020


Author: Fangrui Song
Date: 2020-12-02T22:02:48-08:00
New Revision: 1d6ebdfb66b9d63d34f34ec6ac7ec57eff7cd24b

URL: https://github.com/llvm/llvm-project/commit/1d6ebdfb66b9d63d34f34ec6ac7ec57eff7cd24b
DIFF: https://github.com/llvm/llvm-project/commit/1d6ebdfb66b9d63d34f34ec6ac7ec57eff7cd24b.diff

LOG: Switch from llvm::is_trivially_copyable to std::is_trivially_copyable

GCC<5 did not support std::is_trivially_copyable. Now LLVM builds require 5.1
we can migrate to std::is_trivially_copyable.

The Optional.h change made MSVC choke
(https://buildkite.com/llvm-project/premerge-checks/builds/18587#cd1bb616-ffdc-4581-9795-b42c284196de)
so I leave it out for now.

Differential Revision: https://reviews.llvm.org/D92514

Added: 
    

Modified: 
    llvm/docs/ProgrammersManual.rst
    llvm/include/llvm/ADT/DenseMap.h
    llvm/include/llvm/ADT/STLExtras.h
    llvm/include/llvm/DebugInfo/CodeView/TypeHashing.h
    llvm/tools/llvm-diff/DifferenceEngine.cpp
    llvm/unittests/ADT/ArrayRefTest.cpp
    llvm/unittests/ADT/ImmutableListTest.cpp
    llvm/unittests/ADT/OptionalTest.cpp
    llvm/unittests/ADT/PointerIntPairTest.cpp
    llvm/unittests/ADT/StringRefTest.cpp
    llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp
    llvm/unittests/Bitstream/BitstreamReaderTest.cpp
    llvm/unittests/CodeGen/MachineInstrTest.cpp
    llvm/unittests/CodeGen/TypeTraitsTest.cpp
    llvm/unittests/IR/CFGBuilder.cpp
    llvm/unittests/Support/ScaledNumberTest.cpp

Removed: 
    


################################################################################
diff  --git a/llvm/docs/ProgrammersManual.rst b/llvm/docs/ProgrammersManual.rst
index d9925d69d9f6..e303a7a18eba 100644
--- a/llvm/docs/ProgrammersManual.rst
+++ b/llvm/docs/ProgrammersManual.rst
@@ -1530,7 +1530,7 @@ SmallVector has grown a few other minor advantages over std::vector, causing
 #. std::vector is exception-safe, and some implementations have pessimizations
    that copy elements when SmallVector would move them.
 
-#. SmallVector understands ``llvm::is_trivially_copyable<Type>`` and uses realloc aggressively.
+#. SmallVector understands ``std::is_trivially_copyable<Type>`` and uses realloc aggressively.
 
 #. Many LLVM APIs take a SmallVectorImpl as an out parameter (see the note
    below).

diff  --git a/llvm/include/llvm/ADT/DenseMap.h b/llvm/include/llvm/ADT/DenseMap.h
index 42e4fc84175c..7f7a4593ae36 100644
--- a/llvm/include/llvm/ADT/DenseMap.h
+++ b/llvm/include/llvm/ADT/DenseMap.h
@@ -426,8 +426,8 @@ class DenseMapBase : public DebugEpochBase {
     setNumEntries(other.getNumEntries());
     setNumTombstones(other.getNumTombstones());
 
-    if (is_trivially_copyable<KeyT>::value &&
-        is_trivially_copyable<ValueT>::value)
+    if (std::is_trivially_copyable<KeyT>::value &&
+        std::is_trivially_copyable<ValueT>::value)
       memcpy(reinterpret_cast<void *>(getBuckets()), other.getBuckets(),
              getNumBuckets() * sizeof(BucketT));
     else

diff  --git a/llvm/include/llvm/ADT/STLExtras.h b/llvm/include/llvm/ADT/STLExtras.h
index 5a5d47b783c2..1d6faf6509f9 100644
--- a/llvm/include/llvm/ADT/STLExtras.h
+++ b/llvm/include/llvm/ADT/STLExtras.h
@@ -1428,7 +1428,7 @@ template <typename T>
 // is trivially copyable.
 using sort_trivially_copyable = conjunction<
     std::is_pointer<T>,
-    is_trivially_copyable<typename std::iterator_traits<T>::value_type>>;
+    std::is_trivially_copyable<typename std::iterator_traits<T>::value_type>>;
 } // namespace detail
 
 // Provide wrappers to std::sort which shuffle the elements before sorting

diff  --git a/llvm/include/llvm/DebugInfo/CodeView/TypeHashing.h b/llvm/include/llvm/DebugInfo/CodeView/TypeHashing.h
index e6ade770457c..9f34d026b1ba 100644
--- a/llvm/include/llvm/DebugInfo/CodeView/TypeHashing.h
+++ b/llvm/include/llvm/DebugInfo/CodeView/TypeHashing.h
@@ -171,15 +171,10 @@ struct GloballyHashedType {
     return Hashes;
   }
 };
-#if defined(_MSC_VER)
-// is_trivially_copyable is not available in older versions of libc++, but it is
-// available in all supported versions of MSVC, so at least this gives us some
-// coverage.
 static_assert(std::is_trivially_copyable<GloballyHashedType>::value,
               "GloballyHashedType must be trivially copyable so that we can "
               "reinterpret_cast arrays of hash data to arrays of "
               "GloballyHashedType");
-#endif
 } // namespace codeview
 
 template <> struct DenseMapInfo<codeview::LocallyHashedType> {

diff  --git a/llvm/tools/llvm-
diff /DifferenceEngine.cpp b/llvm/tools/llvm-
diff /DifferenceEngine.cpp
index 2cf1afbc6af5..64c0dc61e806 100644
--- a/llvm/tools/llvm-
diff /DifferenceEngine.cpp
+++ b/llvm/tools/llvm-
diff /DifferenceEngine.cpp
@@ -67,7 +67,7 @@ class PriorityQueue {
     unsigned NewSize = Storage.size() - 1;
     if (NewSize) {
       // Move the slot at the end to the beginning.
-      if (is_trivially_copyable<T>::value)
+      if (std::is_trivially_copyable<T>::value)
         Storage[0] = Storage[NewSize];
       else
         std::swap(Storage[0], Storage[NewSize]);

diff  --git a/llvm/unittests/ADT/ArrayRefTest.cpp b/llvm/unittests/ADT/ArrayRefTest.cpp
index 4690319ae52e..f3da4c675a85 100644
--- a/llvm/unittests/ADT/ArrayRefTest.cpp
+++ b/llvm/unittests/ADT/ArrayRefTest.cpp
@@ -262,7 +262,7 @@ TEST(ArrayRefTest, makeArrayRefFromStdArray) {
   }
 }
 
-static_assert(is_trivially_copyable<ArrayRef<int>>::value,
+static_assert(std::is_trivially_copyable<ArrayRef<int>>::value,
               "trivially copyable");
 
 } // end anonymous namespace

diff  --git a/llvm/unittests/ADT/ImmutableListTest.cpp b/llvm/unittests/ADT/ImmutableListTest.cpp
index b0b1e0e6c29f..ab3b8b472b90 100644
--- a/llvm/unittests/ADT/ImmutableListTest.cpp
+++ b/llvm/unittests/ADT/ImmutableListTest.cpp
@@ -267,7 +267,7 @@ TEST_F(ImmutableListTest, LongListOrderingTest) {
   ASSERT_EQ(6, i);
 }
 
-static_assert(is_trivially_copyable<ImmutableList<Wrapper<long>>>::value,
+static_assert(std::is_trivially_copyable<ImmutableList<Wrapper<long>>>::value,
               "trivially copyable");
 
 } // namespace

diff  --git a/llvm/unittests/ADT/OptionalTest.cpp b/llvm/unittests/ADT/OptionalTest.cpp
index 249c9268bcfd..7506453c4d90 100644
--- a/llvm/unittests/ADT/OptionalTest.cpp
+++ b/llvm/unittests/ADT/OptionalTest.cpp
@@ -17,10 +17,10 @@
 
 using namespace llvm;
 
-static_assert(is_trivially_copyable<Optional<int>>::value,
-          "trivially copyable");
+static_assert(std::is_trivially_copyable<Optional<int>>::value,
+              "trivially copyable");
 
-static_assert(is_trivially_copyable<Optional<std::array<int, 3>>>::value,
+static_assert(std::is_trivially_copyable<Optional<std::array<int, 3>>>::value,
               "trivially copyable");
 
 void OptionalWorksInConstexpr() {
@@ -66,8 +66,8 @@ unsigned NonDefaultConstructible::Destructions = 0;
 unsigned NonDefaultConstructible::CopyAssignments = 0;
 
 static_assert(
-      !is_trivially_copyable<Optional<NonDefaultConstructible>>::value,
-      "not trivially copyable");
+    !std::is_trivially_copyable<Optional<NonDefaultConstructible>>::value,
+    "not trivially copyable");
 
 // Test fixture
 class OptionalTest : public testing::Test {
@@ -227,9 +227,8 @@ struct MultiArgConstructor {
 };
 unsigned MultiArgConstructor::Destructions = 0;
 
-static_assert(
-  !is_trivially_copyable<Optional<MultiArgConstructor>>::value,
-  "not trivially copyable");
+static_assert(!std::is_trivially_copyable<Optional<MultiArgConstructor>>::value,
+              "not trivially copyable");
 
 TEST_F(OptionalTest, Emplace) {
   MultiArgConstructor::ResetCounts();
@@ -278,7 +277,7 @@ unsigned MoveOnly::MoveConstructions = 0;
 unsigned MoveOnly::Destructions = 0;
 unsigned MoveOnly::MoveAssignments = 0;
 
-static_assert(!is_trivially_copyable<Optional<MoveOnly>>::value,
+static_assert(!std::is_trivially_copyable<Optional<MoveOnly>>::value,
               "not trivially copyable");
 
 TEST_F(OptionalTest, MoveOnlyNull) {
@@ -382,7 +381,7 @@ struct Immovable {
 unsigned Immovable::Constructions = 0;
 unsigned Immovable::Destructions = 0;
 
-static_assert(!is_trivially_copyable<Optional<Immovable>>::value,
+static_assert(!std::is_trivially_copyable<Optional<Immovable>>::value,
               "not trivially copyable");
 
 TEST_F(OptionalTest, ImmovableEmplace) {

diff  --git a/llvm/unittests/ADT/PointerIntPairTest.cpp b/llvm/unittests/ADT/PointerIntPairTest.cpp
index b8ba3e32b288..8a42e5b9f557 100644
--- a/llvm/unittests/ADT/PointerIntPairTest.cpp
+++ b/llvm/unittests/ADT/PointerIntPairTest.cpp
@@ -62,7 +62,7 @@ TEST(PointerIntPairTest, GetSet) {
   EXPECT_EQ(&s, Pair2.getPointer());
   EXPECT_EQ(E::Case3, Pair2.getInt());
 
-  static_assert(is_trivially_copyable<PointerIntPair<S *, 2, E>>::value,
+  static_assert(std::is_trivially_copyable<PointerIntPair<S *, 2, E>>::value,
                 "trivially copyable");
 }
 
@@ -101,7 +101,7 @@ TEST(PointerIntPairTest, ManyUnusedBits) {
             (int)PointerLikeTypeTraits<decltype(pair)>::NumLowBitsAvailable);
 
   static_assert(
-      is_trivially_copyable<
+      std::is_trivially_copyable<
           PointerIntPair<Fixnum31, 1, bool, FixnumPointerTraits>>::value,
       "trivially copyable");
 }

diff  --git a/llvm/unittests/ADT/StringRefTest.cpp b/llvm/unittests/ADT/StringRefTest.cpp
index fbf2d8422a44..50e38c50f621 100644
--- a/llvm/unittests/ADT/StringRefTest.cpp
+++ b/llvm/unittests/ADT/StringRefTest.cpp
@@ -1087,6 +1087,7 @@ TEST(StringRefTest, GTestPrinter) {
   EXPECT_EQ(R"("foo")", ::testing::PrintToString(StringRef("foo")));
 }
 
-static_assert(is_trivially_copyable<StringRef>::value, "trivially copyable");
+static_assert(std::is_trivially_copyable<StringRef>::value,
+              "trivially copyable");
 
 } // end anonymous namespace

diff  --git a/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp b/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp
index 2aeba947a745..5dd399517164 100644
--- a/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp
+++ b/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp
@@ -91,7 +91,7 @@ TEST_F(BlockFrequencyInfoTest, Basic) {
   EXPECT_EQ(BFI.getBlockFreq(BB3).getFrequency(), BB3Freq);
 }
 
-static_assert(is_trivially_copyable<bfi_detail::BlockMass>::value,
+static_assert(std::is_trivially_copyable<bfi_detail::BlockMass>::value,
               "trivially copyable");
 
 } // end anonymous namespace

diff  --git a/llvm/unittests/Bitstream/BitstreamReaderTest.cpp b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp
index f58af220f2d1..669288e42647 100644
--- a/llvm/unittests/Bitstream/BitstreamReaderTest.cpp
+++ b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp
@@ -161,7 +161,7 @@ TEST(BitstreamReaderTest, shortRead) {
   }
 }
 
-static_assert(is_trivially_copyable<BitCodeAbbrevOp>::value,
+static_assert(std::is_trivially_copyable<BitCodeAbbrevOp>::value,
               "trivially copyable");
 
 } // end anonymous namespace

diff  --git a/llvm/unittests/CodeGen/MachineInstrTest.cpp b/llvm/unittests/CodeGen/MachineInstrTest.cpp
index 33baaf62efdf..7c9faeca829b 100644
--- a/llvm/unittests/CodeGen/MachineInstrTest.cpp
+++ b/llvm/unittests/CodeGen/MachineInstrTest.cpp
@@ -383,6 +383,7 @@ TEST(MachineInstrExtraInfo, RemoveExtraInfo) {
   ASSERT_FALSE(MI->getHeapAllocMarker());
 }
 
-static_assert(is_trivially_copyable<MCOperand>::value, "trivially copyable");
+static_assert(std::is_trivially_copyable<MCOperand>::value,
+              "trivially copyable");
 
 } // end namespace

diff  --git a/llvm/unittests/CodeGen/TypeTraitsTest.cpp b/llvm/unittests/CodeGen/TypeTraitsTest.cpp
index 840375bd4ab5..af1f36c1e945 100644
--- a/llvm/unittests/CodeGen/TypeTraitsTest.cpp
+++ b/llvm/unittests/CodeGen/TypeTraitsTest.cpp
@@ -12,14 +12,18 @@
 #include "llvm/CodeGen/SlotIndexes.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "gtest/gtest.h"
+#include <type_traits>
 
 using namespace llvm;
 
 #if __has_feature(is_trivially_copyable) || (defined(__GNUC__) && __GNUC__ >= 5)
-static_assert(is_trivially_copyable<PressureChange>::value, "trivially copyable");
-static_assert(is_trivially_copyable<SDep>::value, "trivially copyable");
-static_assert(is_trivially_copyable<SDValue>::value, "trivially copyable");
-static_assert(is_trivially_copyable<SlotIndex>::value, "trivially copyable");
-static_assert(is_trivially_copyable<IdentifyingPassPtr>::value, "trivially copyable");
+static_assert(std::is_trivially_copyable<PressureChange>::value,
+              "trivially copyable");
+static_assert(std::is_trivially_copyable<SDep>::value, "trivially copyable");
+static_assert(std::is_trivially_copyable<SDValue>::value, "trivially copyable");
+static_assert(std::is_trivially_copyable<SlotIndex>::value,
+              "trivially copyable");
+static_assert(std::is_trivially_copyable<IdentifyingPassPtr>::value,
+              "trivially copyable");
 #endif
 

diff  --git a/llvm/unittests/IR/CFGBuilder.cpp b/llvm/unittests/IR/CFGBuilder.cpp
index 3583ab2a8a55..c9bc52ca7a66 100644
--- a/llvm/unittests/IR/CFGBuilder.cpp
+++ b/llvm/unittests/IR/CFGBuilder.cpp
@@ -267,10 +267,11 @@ TEST(CFGBuilder, Rebuild) {
   EXPECT_TRUE(isa<SwitchInst>(B.getOrAddBlock("d")->getTerminator()));
 }
 
-static_assert(is_trivially_copyable<succ_iterator>::value,
+static_assert(std::is_trivially_copyable<succ_iterator>::value,
               "trivially copyable");
-static_assert(is_trivially_copyable<const_succ_iterator>::value,
+static_assert(std::is_trivially_copyable<const_succ_iterator>::value,
               "trivially copyable");
-static_assert(is_trivially_copyable<succ_range>::value, "trivially copyable");
-static_assert(is_trivially_copyable<const_succ_range>::value,
+static_assert(std::is_trivially_copyable<succ_range>::value,
+              "trivially copyable");
+static_assert(std::is_trivially_copyable<const_succ_range>::value,
               "trivially copyable");

diff  --git a/llvm/unittests/Support/ScaledNumberTest.cpp b/llvm/unittests/Support/ScaledNumberTest.cpp
index 3fa63b7bf3c7..82ecce09444d 100644
--- a/llvm/unittests/Support/ScaledNumberTest.cpp
+++ b/llvm/unittests/Support/ScaledNumberTest.cpp
@@ -562,7 +562,7 @@ TEST(ScaledNumberHelpersTest, toIntBug) {
   EXPECT_EQ(1u, (n * n).toInt<uint32_t>());
 }
 
-static_assert(is_trivially_copyable<ScaledNumber<uint32_t>>::value,
+static_assert(std::is_trivially_copyable<ScaledNumber<uint32_t>>::value,
               "trivially copyable");
 
 } // end namespace


        


More information about the llvm-branch-commits mailing list