xref: /llvm-project/llvm/unittests/CodeGen/AllocationOrderTest.cpp (revision b268e24d4349d586334dd6f47aa99b2196b1046e)
16d193ba3SMircea Trofin //===- llvm/unittest/CodeGen/AllocationOrderTest.cpp - AllocationOrder tests =//
26d193ba3SMircea Trofin //
36d193ba3SMircea Trofin // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
46d193ba3SMircea Trofin // See https://llvm.org/LICENSE.txt for license information.
56d193ba3SMircea Trofin // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
66d193ba3SMircea Trofin //
76d193ba3SMircea Trofin //===----------------------------------------------------------------------===//
86d193ba3SMircea Trofin 
96d193ba3SMircea Trofin #include "../lib/CodeGen/AllocationOrder.h"
106d193ba3SMircea Trofin #include "gtest/gtest.h"
116d193ba3SMircea Trofin 
126d193ba3SMircea Trofin using namespace llvm;
136d193ba3SMircea Trofin 
146d193ba3SMircea Trofin namespace {
loadOrder(const AllocationOrder & O,unsigned Limit=0)15*b268e24dSMircea Trofin std::vector<MCPhysReg> loadOrder(const AllocationOrder &O, unsigned Limit = 0) {
166d193ba3SMircea Trofin   std::vector<MCPhysReg> Ret;
17*b268e24dSMircea Trofin   if (Limit == 0)
18*b268e24dSMircea Trofin     for (auto R : O)
196d193ba3SMircea Trofin       Ret.push_back(R);
20*b268e24dSMircea Trofin   else
21*b268e24dSMircea Trofin     for (auto I = O.begin(), E = O.getOrderLimitEnd(Limit); I != E; ++I)
22*b268e24dSMircea Trofin       Ret.push_back(*I);
236d193ba3SMircea Trofin   return Ret;
246d193ba3SMircea Trofin }
256d193ba3SMircea Trofin } // namespace
266d193ba3SMircea Trofin 
TEST(AllocationOrderTest,Basic)276d193ba3SMircea Trofin TEST(AllocationOrderTest, Basic) {
286d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Hints = {1, 2, 3};
296d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Order = {4, 5, 6, 7};
306d193ba3SMircea Trofin   AllocationOrder O(std::move(Hints), Order, false);
316d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3, 4, 5, 6, 7}), loadOrder(O));
326d193ba3SMircea Trofin }
336d193ba3SMircea Trofin 
TEST(AllocationOrderTest,Duplicates)346d193ba3SMircea Trofin TEST(AllocationOrderTest, Duplicates) {
356d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Hints = {1, 2, 3};
366d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Order = {4, 1, 5, 6};
376d193ba3SMircea Trofin   AllocationOrder O(std::move(Hints), Order, false);
386d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3, 4, 5, 6}), loadOrder(O));
396d193ba3SMircea Trofin }
406d193ba3SMircea Trofin 
TEST(AllocationOrderTest,HardHints)416d193ba3SMircea Trofin TEST(AllocationOrderTest, HardHints) {
426d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Hints = {1, 2, 3};
436d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Order = {4, 5, 6, 7};
446d193ba3SMircea Trofin   AllocationOrder O(std::move(Hints), Order, true);
456d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3}), loadOrder(O));
466d193ba3SMircea Trofin }
476d193ba3SMircea Trofin 
TEST(AllocationOrderTest,LimitsBasic)486d193ba3SMircea Trofin TEST(AllocationOrderTest, LimitsBasic) {
496d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Hints = {1, 2, 3};
506d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Order = {4, 5, 6, 7};
516d193ba3SMircea Trofin   AllocationOrder O(std::move(Hints), Order, false);
526d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3, 4, 5, 6, 7}), loadOrder(O, 0));
536d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3, 4}), loadOrder(O, 1));
54*b268e24dSMircea Trofin   EXPECT_EQ(O.end(), O.getOrderLimitEnd(0));
556d193ba3SMircea Trofin }
566d193ba3SMircea Trofin 
TEST(AllocationOrderTest,LimitsDuplicates)576d193ba3SMircea Trofin TEST(AllocationOrderTest, LimitsDuplicates) {
586d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Hints = {1, 2, 3};
596d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Order = {4, 1, 5, 6};
606d193ba3SMircea Trofin   AllocationOrder O(std::move(Hints), Order, false);
616d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3, 4}), loadOrder(O, 1));
626d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3, 4}), loadOrder(O, 2));
636d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3, 4, 5}), loadOrder(O, 3));
646d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3, 4, 5, 6}), loadOrder(O, 4));
656d193ba3SMircea Trofin }
666d193ba3SMircea Trofin 
TEST(AllocationOrderTest,LimitsHardHints)676d193ba3SMircea Trofin TEST(AllocationOrderTest, LimitsHardHints) {
686d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Hints = {1, 2, 3};
696d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Order = {4, 1, 5, 6};
706d193ba3SMircea Trofin   AllocationOrder O(std::move(Hints), Order, true);
716d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3}), loadOrder(O, 1));
726d193ba3SMircea Trofin }
736d193ba3SMircea Trofin 
TEST(AllocationOrderTest,DuplicateIsFirst)746d193ba3SMircea Trofin TEST(AllocationOrderTest, DuplicateIsFirst) {
756d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Hints = {1, 2, 3};
766d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Order = {1, 4, 5, 6};
776d193ba3SMircea Trofin   AllocationOrder O(std::move(Hints), Order, false);
786d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3, 4, 5, 6}), loadOrder(O));
796d193ba3SMircea Trofin }
806d193ba3SMircea Trofin 
TEST(AllocationOrderTest,DuplicateIsFirstWithLimits)816d193ba3SMircea Trofin TEST(AllocationOrderTest, DuplicateIsFirstWithLimits) {
826d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Hints = {1, 2, 3};
836d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Order = {1, 4, 5, 6};
846d193ba3SMircea Trofin   AllocationOrder O(std::move(Hints), Order, false);
856d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3}), loadOrder(O, 1));
866d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3, 4}), loadOrder(O, 2));
876d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3, 4, 5}), loadOrder(O, 3));
886d193ba3SMircea Trofin }
896d193ba3SMircea Trofin 
TEST(AllocationOrderTest,NoHints)906d193ba3SMircea Trofin TEST(AllocationOrderTest, NoHints) {
916d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Hints;
926d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Order = {1, 2, 3, 4};
936d193ba3SMircea Trofin   AllocationOrder O(std::move(Hints), Order, false);
946d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3, 4}), loadOrder(O));
956d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2}), loadOrder(O, 2));
966d193ba3SMircea Trofin   EXPECT_EQ((std::vector<MCPhysReg>{1, 2, 3}), loadOrder(O, 3));
976d193ba3SMircea Trofin }
986d193ba3SMircea Trofin 
TEST(AllocationOrderTest,IsHintTest)996d193ba3SMircea Trofin TEST(AllocationOrderTest, IsHintTest) {
1006d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Hints = {1, 2, 3};
1016d193ba3SMircea Trofin   SmallVector<MCPhysReg, 16> Order = {4, 1, 5, 6};
1026d193ba3SMircea Trofin   AllocationOrder O(std::move(Hints), Order, false);
103*b268e24dSMircea Trofin   auto I = O.begin();
104*b268e24dSMircea Trofin   auto V = *I;
105*b268e24dSMircea Trofin   EXPECT_TRUE(I.isHint());
1066d193ba3SMircea Trofin   EXPECT_EQ(V, 1U);
107*b268e24dSMircea Trofin   ++I;
108*b268e24dSMircea Trofin   EXPECT_TRUE(I.isHint());
109*b268e24dSMircea Trofin   ++I;
110*b268e24dSMircea Trofin   EXPECT_TRUE(I.isHint());
111*b268e24dSMircea Trofin   V = *(++I);
112*b268e24dSMircea Trofin   EXPECT_FALSE(I.isHint());
1136d193ba3SMircea Trofin   EXPECT_EQ(V, 4U);
114*b268e24dSMircea Trofin   V = *(++I);
1156d193ba3SMircea Trofin   EXPECT_TRUE(O.isHint(1));
116*b268e24dSMircea Trofin   EXPECT_FALSE(I.isHint());
1176d193ba3SMircea Trofin   EXPECT_EQ(V, 5U);
1186d193ba3SMircea Trofin }
119