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