1 //===- ConstantFoldingTest.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-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "GISelMITest.h"
10 #include "llvm/CodeGen/GlobalISel/CSEMIRBuilder.h"
11 #include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
12 #include "llvm/CodeGen/GlobalISel/Utils.h"
13 #include "llvm/CodeGen/MachineFunction.h"
14 #include "gtest/gtest.h"
15
16 using namespace llvm;
17
18 namespace {
19
TEST_F(AArch64GISelMITest,FoldWithBuilder)20 TEST_F(AArch64GISelMITest, FoldWithBuilder) {
21 setUp();
22 if (!TM)
23 GTEST_SKIP();
24 // Try to use the FoldableInstructionsBuilder to build binary ops.
25 CSEMIRBuilder CFB(B.getState());
26 LLT s32 = LLT::scalar(32);
27 int64_t Cst;
28 auto MIBCAdd =
29 CFB.buildAdd(s32, CFB.buildConstant(s32, 0), CFB.buildConstant(s32, 1));
30 // This should be a constant now.
31 bool match = mi_match(MIBCAdd.getReg(0), *MRI, m_ICst(Cst));
32 EXPECT_TRUE(match);
33 EXPECT_EQ(Cst, 1);
34 auto MIBCAdd1 =
35 CFB.buildInstr(TargetOpcode::G_ADD, {s32},
36 {CFB.buildConstant(s32, 0), CFB.buildConstant(s32, 1)});
37 // This should be a constant now.
38 match = mi_match(MIBCAdd1.getReg(0), *MRI, m_ICst(Cst));
39 EXPECT_TRUE(match);
40 EXPECT_EQ(Cst, 1);
41
42 // Try one of the other constructors of MachineIRBuilder to make sure it's
43 // compatible.
44 CSEMIRBuilder CFB1(*MF);
45 CFB1.setInsertPt(*EntryMBB, EntryMBB->end());
46 auto MIBCSub =
47 CFB1.buildInstr(TargetOpcode::G_SUB, {s32},
48 {CFB1.buildConstant(s32, 1), CFB1.buildConstant(s32, 1)});
49 // This should be a constant now.
50 match = mi_match(MIBCSub.getReg(0), *MRI, m_ICst(Cst));
51 EXPECT_TRUE(match);
52 EXPECT_EQ(Cst, 0);
53
54 auto MIBCSext1 =
55 CFB1.buildInstr(TargetOpcode::G_SEXT_INREG, {s32},
56 {CFB1.buildConstant(s32, 0x01), uint64_t(8)});
57 // This should be a constant now.
58 match = mi_match(MIBCSext1.getReg(0), *MRI, m_ICst(Cst));
59 EXPECT_TRUE(match);
60 EXPECT_EQ(1, Cst);
61
62 auto MIBCSext2 =
63 CFB1.buildInstr(TargetOpcode::G_SEXT_INREG, {s32},
64 {CFB1.buildConstant(s32, 0x80), uint64_t(8)});
65 // This should be a constant now.
66 match = mi_match(MIBCSext2.getReg(0), *MRI, m_ICst(Cst));
67 EXPECT_TRUE(match);
68 EXPECT_EQ(-0x80, Cst);
69 }
70
TEST_F(AArch64GISelMITest,FoldBinOp)71 TEST_F(AArch64GISelMITest, FoldBinOp) {
72 setUp();
73 if (!TM)
74 GTEST_SKIP();
75
76 LLT s32{LLT::scalar(32)};
77 auto MIBCst1 = B.buildConstant(s32, 16);
78 auto MIBCst2 = B.buildConstant(s32, 9);
79 auto MIBFCst1 = B.buildFConstant(s32, 1.0000001);
80 auto MIBFCst2 = B.buildFConstant(s32, 2.0);
81
82 // Test G_ADD folding Integer + Mixed Int-Float cases
83 std::optional<APInt> FoldGAddInt = ConstantFoldBinOp(
84 TargetOpcode::G_ADD, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
85 EXPECT_TRUE(FoldGAddInt.has_value());
86 EXPECT_EQ(25ULL, FoldGAddInt->getLimitedValue());
87 std::optional<APInt> FoldGAddMix = ConstantFoldBinOp(
88 TargetOpcode::G_ADD, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI);
89 EXPECT_TRUE(FoldGAddMix.has_value());
90 EXPECT_EQ(1073741840ULL, FoldGAddMix->getLimitedValue());
91
92 // Test G_AND folding Integer + Mixed Int-Float cases
93 std::optional<APInt> FoldGAndInt = ConstantFoldBinOp(
94 TargetOpcode::G_AND, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
95 EXPECT_TRUE(FoldGAndInt.has_value());
96 EXPECT_EQ(0ULL, FoldGAndInt->getLimitedValue());
97 std::optional<APInt> FoldGAndMix = ConstantFoldBinOp(
98 TargetOpcode::G_AND, MIBCst2.getReg(0), MIBFCst1.getReg(0), *MRI);
99 EXPECT_TRUE(FoldGAndMix.has_value());
100 EXPECT_EQ(1ULL, FoldGAndMix->getLimitedValue());
101
102 // Test G_ASHR folding Integer + Mixed cases
103 std::optional<APInt> FoldGAShrInt = ConstantFoldBinOp(
104 TargetOpcode::G_ASHR, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
105 EXPECT_TRUE(FoldGAShrInt.has_value());
106 EXPECT_EQ(0ULL, FoldGAShrInt->getLimitedValue());
107 std::optional<APInt> FoldGAShrMix = ConstantFoldBinOp(
108 TargetOpcode::G_ASHR, MIBFCst2.getReg(0), MIBCst2.getReg(0), *MRI);
109 EXPECT_TRUE(FoldGAShrMix.has_value());
110 EXPECT_EQ(2097152ULL, FoldGAShrMix->getLimitedValue());
111
112 // Test G_LSHR folding Integer + Mixed Int-Float cases
113 std::optional<APInt> FoldGLShrInt = ConstantFoldBinOp(
114 TargetOpcode::G_LSHR, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
115 EXPECT_TRUE(FoldGLShrInt.has_value());
116 EXPECT_EQ(0ULL, FoldGLShrInt->getLimitedValue());
117 std::optional<APInt> FoldGLShrMix = ConstantFoldBinOp(
118 TargetOpcode::G_LSHR, MIBFCst1.getReg(0), MIBCst2.getReg(0), *MRI);
119 EXPECT_TRUE(FoldGLShrMix.has_value());
120 EXPECT_EQ(2080768ULL, FoldGLShrMix->getLimitedValue());
121
122 // Test G_MUL folding Integer + Mixed Int-Float cases
123 std::optional<APInt> FoldGMulInt = ConstantFoldBinOp(
124 TargetOpcode::G_MUL, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
125 EXPECT_TRUE(FoldGMulInt.has_value());
126 EXPECT_EQ(144ULL, FoldGMulInt->getLimitedValue());
127 std::optional<APInt> FoldGMulMix = ConstantFoldBinOp(
128 TargetOpcode::G_MUL, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI);
129 EXPECT_TRUE(FoldGMulMix.has_value());
130 EXPECT_EQ(0ULL, FoldGMulMix->getLimitedValue());
131
132 // Test G_OR folding Integer + Mixed Int-Float cases
133 std::optional<APInt> FoldGOrInt = ConstantFoldBinOp(
134 TargetOpcode::G_OR, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
135 EXPECT_TRUE(FoldGOrInt.has_value());
136 EXPECT_EQ(25ULL, FoldGOrInt->getLimitedValue());
137 std::optional<APInt> FoldGOrMix = ConstantFoldBinOp(
138 TargetOpcode::G_OR, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI);
139 EXPECT_TRUE(FoldGOrMix.has_value());
140 EXPECT_EQ(1073741840ULL, FoldGOrMix->getLimitedValue());
141
142 // Test G_SHL folding Integer + Mixed Int-Float cases
143 std::optional<APInt> FoldGShlInt = ConstantFoldBinOp(
144 TargetOpcode::G_SHL, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
145 EXPECT_TRUE(FoldGShlInt.has_value());
146 EXPECT_EQ(8192ULL, FoldGShlInt->getLimitedValue());
147 std::optional<APInt> FoldGShlMix = ConstantFoldBinOp(
148 TargetOpcode::G_SHL, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI);
149 EXPECT_TRUE(FoldGShlMix.has_value());
150 EXPECT_EQ(0ULL, FoldGShlMix->getLimitedValue());
151
152 // Test G_SUB folding Integer + Mixed Int-Float cases
153 std::optional<APInt> FoldGSubInt = ConstantFoldBinOp(
154 TargetOpcode::G_SUB, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
155 EXPECT_TRUE(FoldGSubInt.has_value());
156 EXPECT_EQ(7ULL, FoldGSubInt->getLimitedValue());
157 std::optional<APInt> FoldGSubMix = ConstantFoldBinOp(
158 TargetOpcode::G_SUB, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI);
159 EXPECT_TRUE(FoldGSubMix.has_value());
160 EXPECT_EQ(3221225488ULL, FoldGSubMix->getLimitedValue());
161
162 // Test G_XOR folding Integer + Mixed Int-Float cases
163 std::optional<APInt> FoldGXorInt = ConstantFoldBinOp(
164 TargetOpcode::G_XOR, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
165 EXPECT_TRUE(FoldGXorInt.has_value());
166 EXPECT_EQ(25ULL, FoldGXorInt->getLimitedValue());
167 std::optional<APInt> FoldGXorMix = ConstantFoldBinOp(
168 TargetOpcode::G_XOR, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI);
169 EXPECT_TRUE(FoldGXorMix.has_value());
170 EXPECT_EQ(1073741840ULL, FoldGXorMix->getLimitedValue());
171
172 // Test G_UDIV folding Integer + Mixed Int-Float cases
173 std::optional<APInt> FoldGUdivInt = ConstantFoldBinOp(
174 TargetOpcode::G_UDIV, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
175 EXPECT_TRUE(FoldGUdivInt.has_value());
176 EXPECT_EQ(1ULL, FoldGUdivInt->getLimitedValue());
177 std::optional<APInt> FoldGUdivMix = ConstantFoldBinOp(
178 TargetOpcode::G_UDIV, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI);
179 EXPECT_TRUE(FoldGUdivMix.has_value());
180 EXPECT_EQ(0ULL, FoldGUdivMix->getLimitedValue());
181
182 // Test G_SDIV folding Integer + Mixed Int-Float cases
183 std::optional<APInt> FoldGSdivInt = ConstantFoldBinOp(
184 TargetOpcode::G_SDIV, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
185 EXPECT_TRUE(FoldGSdivInt.has_value());
186 EXPECT_EQ(1ULL, FoldGSdivInt->getLimitedValue());
187 std::optional<APInt> FoldGSdivMix = ConstantFoldBinOp(
188 TargetOpcode::G_SDIV, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI);
189 EXPECT_TRUE(FoldGSdivMix.has_value());
190 EXPECT_EQ(0ULL, FoldGSdivMix->getLimitedValue());
191
192 // Test G_UREM folding Integer + Mixed Int-Float cases
193 std::optional<APInt> FoldGUremInt = ConstantFoldBinOp(
194 TargetOpcode::G_UDIV, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
195 EXPECT_TRUE(FoldGUremInt.has_value());
196 EXPECT_EQ(1ULL, FoldGUremInt->getLimitedValue());
197 std::optional<APInt> FoldGUremMix = ConstantFoldBinOp(
198 TargetOpcode::G_UDIV, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI);
199 EXPECT_TRUE(FoldGUremMix.has_value());
200 EXPECT_EQ(0ULL, FoldGUremMix->getLimitedValue());
201
202 // Test G_SREM folding Integer + Mixed Int-Float cases
203 std::optional<APInt> FoldGSremInt = ConstantFoldBinOp(
204 TargetOpcode::G_SREM, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI);
205 EXPECT_TRUE(FoldGSremInt.has_value());
206 EXPECT_EQ(7ULL, FoldGSremInt->getLimitedValue());
207 std::optional<APInt> FoldGSremMix = ConstantFoldBinOp(
208 TargetOpcode::G_SREM, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI);
209 EXPECT_TRUE(FoldGSremMix.has_value());
210 EXPECT_EQ(16ULL, FoldGSremMix->getLimitedValue());
211 }
212
213 } // namespace
214