1 //===----------------------------------------------------------------------===//
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-exception
6 //
7 //===----------------------------------------------------------------------===//
8 #include "llvm/Support/TypeSize.h"
9 #include "gtest/gtest.h"
10
11 using namespace llvm;
12
13 namespace {
14
15 constexpr ElementCount CEElementCount = ElementCount();
16
17 static_assert(!CEElementCount.isScalar());
18 static_assert(!CEElementCount.isVector());
19
20 constexpr ElementCount CEElementCountFixed1 = ElementCount::getFixed(1);
21 static_assert(CEElementCountFixed1.isScalar());
22 static_assert(!CEElementCountFixed1.isVector());
23 static_assert(!CEElementCountFixed1.isScalable());
24
25 constexpr ElementCount CEElementCountFixed3 = ElementCount::getFixed(3);
26 constexpr ElementCount CEElementCountFixed4 = ElementCount::getFixed(4);
27
28 static_assert(!CEElementCountFixed4.isScalar());
29 static_assert(CEElementCountFixed4.isVector());
30 static_assert(CEElementCountFixed4.isKnownEven());
31 static_assert(!CEElementCountFixed3.isKnownEven());
32 static_assert(!CEElementCountFixed4.isScalable());
33 static_assert(!CEElementCountFixed3.isScalable());
34
35 constexpr ElementCount CEElementCountScalable4 = ElementCount::getScalable(4);
36
37 static_assert(CEElementCountScalable4.isScalable());
38 static_assert(!ElementCount().isScalable());
39 static_assert(
40 CEElementCountScalable4.hasKnownScalarFactor(ElementCount::getScalable(2)));
41 static_assert(ElementCount::getScalable(8).getKnownScalarFactor(
42 ElementCount::getScalable(2)) == 4);
43
44 static_assert(CEElementCountScalable4 == ElementCount::get(4, true));
45 static_assert(CEElementCountFixed4 == ElementCount::get(4, false));
46 static_assert(ElementCount::isKnownLT(CEElementCountFixed3,
47 CEElementCountFixed4));
48 static_assert(ElementCount::isKnownLE(CEElementCountFixed3,
49 CEElementCountFixed4));
50 static_assert(ElementCount::isKnownGT(CEElementCountFixed4,
51 CEElementCountFixed3));
52 static_assert(ElementCount::isKnownGE(CEElementCountFixed4,
53 CEElementCountFixed3));
54 static_assert(CEElementCountFixed3.coefficientNextPowerOf2() ==
55 CEElementCountFixed4);
56 static_assert(ElementCount::getFixed(8).divideCoefficientBy(2) ==
57 ElementCount::getFixed(4));
58 static_assert(ElementCount::getFixed(8).multiplyCoefficientBy(3) ==
59 ElementCount::getFixed(24));
60 static_assert(ElementCount::getFixed(8).isKnownMultipleOf(2));
61
62 constexpr TypeSize TSFixed0 = TypeSize::getFixed(0);
63 constexpr TypeSize TSFixed1 = TypeSize::getFixed(1);
64 constexpr TypeSize TSFixed32 = TypeSize::getFixed(32);
65
66 static_assert(TSFixed0.getFixedValue() == 0);
67 static_assert(TSFixed1.getFixedValue() == 1);
68 static_assert(TSFixed32.getFixedValue() == 32);
69 static_assert(TSFixed32.getKnownMinValue() == 32);
70
71 static_assert(TypeSize::getScalable(32).getKnownMinValue() == 32);
72
73 static_assert(TSFixed32 * 2 == TypeSize::getFixed(64));
74 static_assert(TSFixed32 * 2u == TypeSize::getFixed(64));
75 static_assert(TSFixed32 * INT64_C(2) == TypeSize::getFixed(64));
76 static_assert(TSFixed32 * UINT64_C(2) == TypeSize::getFixed(64));
77
78 static_assert(2 * TSFixed32 == TypeSize::getFixed(64));
79 static_assert(2u * TSFixed32 == TypeSize::getFixed(64));
80 static_assert(INT64_C(2) * TSFixed32 == TypeSize::getFixed(64));
81 static_assert(UINT64_C(2) * TSFixed32 == TypeSize::getFixed(64));
82 static_assert(alignTo(TypeSize::getFixed(7), 8) == TypeSize::getFixed(8));
83
84 static_assert(TypeSize::getZero() == TypeSize::getFixed(0));
85 static_assert(TypeSize::getZero() != TypeSize::getScalable(0));
86 static_assert(TypeSize::getFixed(0) != TypeSize::getScalable(0));
87 static_assert(TypeSize::getFixed(0).isZero());
88 static_assert(TypeSize::getScalable(0).isZero());
89 static_assert(TypeSize::getZero().isZero());
90 static_assert(TypeSize::getFixed(0) ==
91 (TypeSize::getFixed(4) - TypeSize::getFixed(4)));
92 static_assert(TypeSize::getScalable(0) ==
93 (TypeSize::getScalable(4) - TypeSize::getScalable(4)));
94 static_assert(TypeSize::getFixed(0) + TypeSize::getScalable(8) ==
95 TypeSize::getScalable(8));
96 static_assert(TypeSize::getScalable(8) + TypeSize::getFixed(0) ==
97 TypeSize::getScalable(8));
98 static_assert(TypeSize::getFixed(8) + TypeSize::getScalable(0) ==
99 TypeSize::getFixed(8));
100 static_assert(TypeSize::getScalable(0) + TypeSize::getFixed(8) ==
101 TypeSize::getFixed(8));
102 static_assert(TypeSize::getScalable(8) - TypeSize::getFixed(0) ==
103 TypeSize::getScalable(8));
104 static_assert(TypeSize::getFixed(8) - TypeSize::getScalable(0) ==
105 TypeSize::getFixed(8));
106
TEST(TypeSize,FailIncompatibleTypes)107 TEST(TypeSize, FailIncompatibleTypes) {
108 EXPECT_DEBUG_DEATH(TypeSize::getFixed(8) + TypeSize::getScalable(8),
109 "Incompatible types");
110 }
111
112 } // namespace
113