unittests/CodeGen/MachineInstrBundleIteratorTest.cpp

   1 //===- MachineInstrBundleIteratorTest.cpp ---------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/CodeGen/MachineInstrBundleIterator.h"
  11 #include "llvm/ADT/ilist_node.h"
  12 #include "gtest/gtest.h"
  13
  14 using namespace llvm;
  15
  16 namespace {
  17
  18 struct MyBundledInstr
  19     : public ilist_node<MyBundledInstr, ilist_sentinel_tracking<true>> {
  20   bool isBundledWithPred() const { return true; }
  21   bool isBundledWithSucc() const { return true; }
  22 };
  23 typedef MachineInstrBundleIterator<MyBundledInstr> bundled_iterator;
  24 typedef MachineInstrBundleIterator<const MyBundledInstr> const_bundled_iterator;
  25 typedef MachineInstrBundleIterator<MyBundledInstr, true>
  26     reverse_bundled_iterator;
  27 typedef MachineInstrBundleIterator<const MyBundledInstr, true>
  28     const_reverse_bundled_iterator;
  29
  30 #ifdef GTEST_HAS_DEATH_TEST
  31 #ifndef NDEBUG
  32 TEST(MachineInstrBundleIteratorTest, CheckForBundles) {
  33   MyBundledInstr MBI;
  34   auto I = MBI.getIterator();
  35   auto RI = I.getReverse();
  36
  37   // Confirm that MBI is always considered bundled.
  38   EXPECT_TRUE(MBI.isBundledWithPred());
  39   EXPECT_TRUE(MBI.isBundledWithSucc());
  40
  41   // Confirm that iterators check in their constructor for bundled iterators.
  42   EXPECT_DEATH((void)static_cast<bundled_iterator>(I),
  43                "not legal to initialize");
  44   EXPECT_DEATH((void)static_cast<bundled_iterator>(MBI),
  45                "not legal to initialize");
  46   EXPECT_DEATH((void)static_cast<bundled_iterator>(&MBI),
  47                "not legal to initialize");
  48   EXPECT_DEATH((void)static_cast<const_bundled_iterator>(I),
  49                "not legal to initialize");
  50   EXPECT_DEATH((void)static_cast<const_bundled_iterator>(MBI),
  51                "not legal to initialize");
  52   EXPECT_DEATH((void)static_cast<const_bundled_iterator>(&MBI),
  53                "not legal to initialize");
  54   EXPECT_DEATH((void)static_cast<reverse_bundled_iterator>(RI),
  55                "not legal to initialize");
  56   EXPECT_DEATH((void)static_cast<reverse_bundled_iterator>(MBI),
  57                "not legal to initialize");
  58   EXPECT_DEATH((void)static_cast<reverse_bundled_iterator>(&MBI),
  59                "not legal to initialize");
  60   EXPECT_DEATH((void)static_cast<const_reverse_bundled_iterator>(RI),
  61                "not legal to initialize");
  62   EXPECT_DEATH((void)static_cast<const_reverse_bundled_iterator>(MBI),
  63                "not legal to initialize");
  64   EXPECT_DEATH((void)static_cast<const_reverse_bundled_iterator>(&MBI),
  65                "not legal to initialize");
  66 }
  67 #endif
  68 #endif
  69
  70 TEST(MachineInstrBundleIteratorTest, CompareToBundledMI) {
  71   MyBundledInstr MBI;
  72   const MyBundledInstr &CMBI = MBI;
  73   bundled_iterator I;
  74   const_bundled_iterator CI;
  75
  76   // Confirm that MBI is always considered bundled.
  77   EXPECT_TRUE(MBI.isBundledWithPred());
  78   EXPECT_TRUE(MBI.isBundledWithSucc());
  79
  80   // These invocations will crash when !NDEBUG if a conversion is taking place.
  81   // These checks confirm that comparison operators don't use any conversion
  82   // operators.
  83   ASSERT_FALSE(MBI == I);
  84   ASSERT_FALSE(&MBI == I);
  85   ASSERT_FALSE(CMBI == I);
  86   ASSERT_FALSE(&CMBI == I);
  87   ASSERT_FALSE(I == MBI);
  88   ASSERT_FALSE(I == &MBI);
  89   ASSERT_FALSE(I == CMBI);
  90   ASSERT_FALSE(I == &CMBI);
  91   ASSERT_FALSE(MBI == CI);
  92   ASSERT_FALSE(&MBI == CI);
  93   ASSERT_FALSE(CMBI == CI);
  94   ASSERT_FALSE(&CMBI == CI);
  95   ASSERT_FALSE(CI == MBI);
  96   ASSERT_FALSE(CI == &MBI);
  97   ASSERT_FALSE(CI == CMBI);
  98   ASSERT_FALSE(CI == &CMBI);
  99   ASSERT_FALSE(MBI.getIterator() == I);
 100   ASSERT_FALSE(CMBI.getIterator() == I);
 101   ASSERT_FALSE(I == MBI.getIterator());
 102   ASSERT_FALSE(I == CMBI.getIterator());
 103   ASSERT_FALSE(MBI.getIterator() == CI);
 104   ASSERT_FALSE(CMBI.getIterator() == CI);
 105   ASSERT_FALSE(CI == MBI.getIterator());
 106   ASSERT_FALSE(CI == CMBI.getIterator());
 107   ASSERT_TRUE(MBI != I);
 108   ASSERT_TRUE(&MBI != I);
 109   ASSERT_TRUE(CMBI != I);
 110   ASSERT_TRUE(&CMBI != I);
 111   ASSERT_TRUE(I != MBI);
 112   ASSERT_TRUE(I != &MBI);
 113   ASSERT_TRUE(I != CMBI);
 114   ASSERT_TRUE(I != &CMBI);
 115   ASSERT_TRUE(MBI != CI);
 116   ASSERT_TRUE(&MBI != CI);
 117   ASSERT_TRUE(CMBI != CI);
 118   ASSERT_TRUE(&CMBI != CI);
 119   ASSERT_TRUE(CI != MBI);
 120   ASSERT_TRUE(CI != &MBI);
 121   ASSERT_TRUE(CI != CMBI);
 122   ASSERT_TRUE(CI != &CMBI);
 123   ASSERT_TRUE(MBI.getIterator() != I);
 124   ASSERT_TRUE(CMBI.getIterator() != I);
 125   ASSERT_TRUE(I != MBI.getIterator());
 126   ASSERT_TRUE(I != CMBI.getIterator());
 127   ASSERT_TRUE(MBI.getIterator() != CI);
 128   ASSERT_TRUE(CMBI.getIterator() != CI);
 129   ASSERT_TRUE(CI != MBI.getIterator());
 130   ASSERT_TRUE(CI != CMBI.getIterator());
 131 }
 132
 133 struct MyUnbundledInstr
 134     : ilist_node<MyUnbundledInstr, ilist_sentinel_tracking<true>> {
 135   bool isBundledWithPred() const { return false; }
 136   bool isBundledWithSucc() const { return false; }
 137 };
 138 typedef MachineInstrBundleIterator<MyUnbundledInstr> unbundled_iterator;
 139 typedef MachineInstrBundleIterator<const MyUnbundledInstr>
 140     const_unbundled_iterator;
 141 typedef MachineInstrBundleIterator<MyUnbundledInstr, true>
 142     reverse_unbundled_iterator;
 143 typedef MachineInstrBundleIterator<const MyUnbundledInstr, true>
 144     const_reverse_unbundled_iterator;
 145
 146 TEST(MachineInstrBundleIteratorTest, ReverseConstructor) {
 147   simple_ilist<MyUnbundledInstr, ilist_sentinel_tracking<true>> L;
 148   const auto &CL = L;
 149   MyUnbundledInstr A, B;
 150   L.insert(L.end(), A);
 151   L.insert(L.end(), B);
 152
 153   // Save typing.
 154   typedef MachineInstrBundleIterator<MyUnbundledInstr> iterator;
 155   typedef MachineInstrBundleIterator<MyUnbundledInstr, true> reverse_iterator;
 156   typedef MachineInstrBundleIterator<const MyUnbundledInstr> const_iterator;
 157   typedef MachineInstrBundleIterator<const MyUnbundledInstr, true>
 158       const_reverse_iterator;
 159
 160   // Convert to bundle iterators.
 161   auto begin = [&]() -> iterator { return L.begin(); };
 162   auto end = [&]() -> iterator { return L.end(); };
 163   auto rbegin = [&]() -> reverse_iterator { return L.rbegin(); };
 164   auto rend = [&]() -> reverse_iterator { return L.rend(); };
 165   auto cbegin = [&]() -> const_iterator { return CL.begin(); };
 166   auto cend = [&]() -> const_iterator { return CL.end(); };
 167   auto crbegin = [&]() -> const_reverse_iterator { return CL.rbegin(); };
 168   auto crend = [&]() -> const_reverse_iterator { return CL.rend(); };
 169
 170   // Check conversion values.
 171   EXPECT_EQ(begin(), iterator(rend()));
 172   EXPECT_EQ(++begin(), iterator(++rbegin()));
 173   EXPECT_EQ(end(), iterator(rbegin()));
 174   EXPECT_EQ(rbegin(), reverse_iterator(end()));
 175   EXPECT_EQ(++rbegin(), reverse_iterator(++begin()));
 176   EXPECT_EQ(rend(), reverse_iterator(begin()));
 177
 178   // Check const iterator constructors.
 179   EXPECT_EQ(cbegin(), const_iterator(rend()));
 180   EXPECT_EQ(cbegin(), const_iterator(crend()));
 181   EXPECT_EQ(crbegin(), const_reverse_iterator(end()));
 182   EXPECT_EQ(crbegin(), const_reverse_iterator(cend()));
 183
 184   // Confirm lack of implicit conversions.
 185   static_assert(!std::is_convertible<iterator, reverse_iterator>::value,
 186                 "unexpected implicit conversion");
 187   static_assert(!std::is_convertible<reverse_iterator, iterator>::value,
 188                 "unexpected implicit conversion");
 189   static_assert(
 190       !std::is_convertible<const_iterator, const_reverse_iterator>::value,
 191       "unexpected implicit conversion");
 192   static_assert(
 193       !std::is_convertible<const_reverse_iterator, const_iterator>::value,
 194       "unexpected implicit conversion");
 195 }
 196
 197 } // end namespace