1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
//===- InstructionCostTest.cpp - InstructionCost tests --------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/InstructionCost.h"
#include "gtest/gtest.h"
#include <limits>
using namespace llvm;
namespace {
struct CostTest : public testing::Test {
CostTest() {}
};
} // namespace
TEST_F(CostTest, DefaultCtor) {
InstructionCost DefaultCost;
ASSERT_TRUE(DefaultCost.isValid());
EXPECT_EQ(*(DefaultCost.getValue()), 0);
}
TEST_F(CostTest, Operators) {
InstructionCost VThree = 3;
InstructionCost VNegTwo = -2;
InstructionCost VSix = 6;
InstructionCost IThreeA = InstructionCost::getInvalid(3);
InstructionCost IThreeB = InstructionCost::getInvalid(3);
InstructionCost ITwo = InstructionCost::getInvalid(2);
InstructionCost TmpCost;
EXPECT_NE(VThree, VNegTwo);
EXPECT_GT(VThree, VNegTwo);
EXPECT_NE(VThree, IThreeA);
EXPECT_EQ(IThreeA, IThreeB);
EXPECT_GE(IThreeA, VNegTwo);
EXPECT_LT(VSix, IThreeA);
EXPECT_LT(VThree, ITwo);
EXPECT_GE(ITwo, VThree);
EXPECT_EQ(VSix - IThreeA, IThreeB);
EXPECT_EQ(VThree - VNegTwo, 5);
EXPECT_EQ(VThree * VNegTwo, -6);
EXPECT_EQ(VSix / VThree, 2);
EXPECT_NE(IThreeA, ITwo);
EXPECT_LT(ITwo, IThreeA);
EXPECT_GT(IThreeA, ITwo);
EXPECT_FALSE(IThreeA.isValid());
EXPECT_EQ(IThreeA.getState(), InstructionCost::Invalid);
TmpCost = VThree + IThreeA;
EXPECT_FALSE(TmpCost.isValid());
// Test increments, decrements
EXPECT_EQ(++VThree, 4);
EXPECT_EQ(VThree++, 4);
EXPECT_EQ(VThree, 5);
EXPECT_EQ(--VThree, 4);
EXPECT_EQ(VThree--, 4);
EXPECT_EQ(VThree, 3);
TmpCost = VThree * IThreeA;
EXPECT_FALSE(TmpCost.isValid());
// Test value extraction
EXPECT_EQ(*(VThree.getValue()), 3);
EXPECT_EQ(IThreeA.getValue(), None);
EXPECT_EQ(std::min(VThree, VNegTwo), -2);
EXPECT_EQ(std::max(VThree, VSix), 6);
// Test saturation
auto Max = InstructionCost::getMax();
auto Min = InstructionCost::getMin();
auto MinusOne = InstructionCost(-1);
auto MinusTwo = InstructionCost(-2);
auto One = InstructionCost(1);
auto Two = InstructionCost(2);
EXPECT_EQ(Max + One, Max);
EXPECT_EQ(Min + MinusOne, Min);
EXPECT_EQ(Min - One, Min);
EXPECT_EQ(Max - MinusOne, Max);
EXPECT_EQ(Max * Two, Max);
EXPECT_EQ(Min * Two, Min);
EXPECT_EQ(Max * MinusTwo, Min);
EXPECT_EQ(Min * MinusTwo, Max);
}
|
