1 //===- PatternMatchTest.cpp -----------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "LegalizerHelperTest.h" 11 12 namespace { 13 14 // Test CTTZ expansion when CTTZ_ZERO_UNDEF is legal or custom, 15 // in which case it becomes CTTZ_ZERO_UNDEF with select. 16 TEST_F(LegalizerHelperTest, LowerBitCountingCTTZ0) { 17 if (!TM) 18 return; 19 20 // Declare your legalization info 21 DefineLegalizerInfo( 22 A, { getActionDefinitionsBuilder(G_CTTZ_ZERO_UNDEF).legalFor({s64}); }); 23 // Build Instr 24 auto MIBCTTZ = B.buildInstr(TargetOpcode::G_CTTZ, LLT::scalar(64), Copies[0]); 25 AInfo Info(MF->getSubtarget()); 26 LegalizerHelper Helper(*MF, Info); 27 // Perform Legalization 28 ASSERT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) == 29 LegalizerHelper::LegalizeResult::Legalized); 30 31 auto CheckStr = R"( 32 CHECK: [[CZU:%[0-9]+]]:_(s64) = G_CTTZ_ZERO_UNDEF %0 33 CHECK: [[ZERO:%[0-9]+]]:_(s64) = G_CONSTANT i64 0 34 CHECK: [[SIXTY4:%[0-9]+]]:_(s64) = G_CONSTANT i64 64 35 CHECK: [[CMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), %0:_(s64), [[ZERO]] 36 CHECK: [[SEL:%[0-9]+]]:_(s64) = G_SELECT [[CMP]]:_(s1), [[SIXTY4]]:_, [[CZU]] 37 )"; 38 39 // Check 40 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 41 } 42 43 // CTTZ expansion in terms of CTLZ 44 TEST_F(LegalizerHelperTest, LowerBitCountingCTTZ1) { 45 if (!TM) 46 return; 47 48 // Declare your legalization info 49 DefineLegalizerInfo(A, 50 { getActionDefinitionsBuilder(G_CTLZ).legalFor({s64}); }); 51 // Build Instr 52 auto MIBCTTZ = B.buildInstr(TargetOpcode::G_CTTZ, LLT::scalar(64), Copies[0]); 53 AInfo Info(MF->getSubtarget()); 54 LegalizerHelper Helper(*MF, Info); 55 // Perform Legalization 56 ASSERT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) == 57 LegalizerHelper::LegalizeResult::Legalized); 58 59 auto CheckStr = R"( 60 CHECK: [[NEG1:%[0-9]+]]:_(s64) = G_CONSTANT i64 -1 61 CHECK: [[NOT:%[0-9]+]]:_(s64) = G_XOR %0:_, [[NEG1]] 62 CHECK: [[SUB1:%[0-9]+]]:_(s64) = G_ADD %0:_, [[NEG1]] 63 CHECK: [[AND1:%[0-9]+]]:_(s64) = G_AND [[NOT]]:_, [[SUB1]]:_ 64 CHECK: [[CST64:%[0-9]+]]:_(s64) = G_CONSTANT i64 64 65 CHECK: [[CTLZ:%[0-9]+]]:_(s64) = G_CTLZ [[AND1]]:_ 66 CHECK: G_SUB [[CST64]]:_, [[CTLZ]]:_ 67 )"; 68 69 // Check 70 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 71 } 72 73 // CTTZ expansion in terms of CTPOP 74 TEST_F(LegalizerHelperTest, LowerBitCountingCTTZ2) { 75 if (!TM) 76 return; 77 78 // Declare your legalization info 79 DefineLegalizerInfo( 80 A, { getActionDefinitionsBuilder(G_CTPOP).legalFor({s64}); }); 81 // Build 82 auto MIBCTTZ = B.buildInstr(TargetOpcode::G_CTTZ, LLT::scalar(64), Copies[0]); 83 AInfo Info(MF->getSubtarget()); 84 LegalizerHelper Helper(*MF, Info); 85 ASSERT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) == 86 LegalizerHelper::LegalizeResult::Legalized); 87 88 auto CheckStr = R"( 89 CHECK: [[NEG1:%[0-9]+]]:_(s64) = G_CONSTANT i64 -1 90 CHECK: [[NOT:%[0-9]+]]:_(s64) = G_XOR %0:_, [[NEG1]] 91 CHECK: [[SUB1:%[0-9]+]]:_(s64) = G_ADD %0:_, [[NEG1]] 92 CHECK: [[AND1:%[0-9]+]]:_(s64) = G_AND [[NOT]]:_, [[SUB1]]:_ 93 CHECK: [[POP:%[0-9]+]]:_(s64) = G_CTPOP [[AND1]] 94 )"; 95 96 // Check 97 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 98 } 99 100 // CTTZ_ZERO_UNDEF expansion in terms of CTTZ 101 TEST_F(LegalizerHelperTest, LowerBitCountingCTTZ3) { 102 if (!TM) 103 return; 104 105 // Declare your legalization info 106 DefineLegalizerInfo(A, 107 { getActionDefinitionsBuilder(G_CTTZ).legalFor({s64}); }); 108 // Build 109 auto MIBCTTZ = 110 B.buildInstr(TargetOpcode::G_CTTZ_ZERO_UNDEF, LLT::scalar(64), Copies[0]); 111 AInfo Info(MF->getSubtarget()); 112 LegalizerHelper Helper(*MF, Info); 113 ASSERT_TRUE(Helper.lower(*MIBCTTZ, 0, LLT::scalar(64)) == 114 LegalizerHelper::LegalizeResult::Legalized); 115 116 auto CheckStr = R"( 117 CHECK: CTTZ 118 )"; 119 120 // Check 121 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 122 } 123 124 // CTLZ expansion in terms of CTLZ_ZERO_UNDEF 125 TEST_F(LegalizerHelperTest, LowerBitCountingCTLZ0) { 126 if (!TM) 127 return; 128 129 // Declare your legalization info 130 DefineLegalizerInfo( 131 A, { getActionDefinitionsBuilder(G_CTLZ_ZERO_UNDEF).legalFor({s64}); }); 132 // Build 133 auto MIBCTLZ = B.buildInstr(TargetOpcode::G_CTLZ, LLT::scalar(64), Copies[0]); 134 AInfo Info(MF->getSubtarget()); 135 LegalizerHelper Helper(*MF, Info); 136 ASSERT_TRUE(Helper.lower(*MIBCTLZ, 0, LLT::scalar(64)) == 137 LegalizerHelper::LegalizeResult::Legalized); 138 139 auto CheckStr = R"( 140 CHECK: [[CZU:%[0-9]+]]:_(s64) = G_CTLZ_ZERO_UNDEF %0 141 CHECK: [[ZERO:%[0-9]+]]:_(s64) = G_CONSTANT i64 0 142 CHECK: [[SIXTY4:%[0-9]+]]:_(s64) = G_CONSTANT i64 64 143 CHECK: [[CMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), %0:_(s64), [[ZERO]] 144 CHECK: [[SEL:%[0-9]+]]:_(s64) = G_SELECT [[CMP]]:_(s1), [[SIXTY4]]:_, [[CZU]] 145 )"; 146 147 // Check 148 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 149 } 150 151 // CTLZ expansion in terms of CTLZ_ZERO_UNDEF if the latter is a libcall 152 TEST_F(LegalizerHelperTest, LowerBitCountingCTLZLibcall) { 153 if (!TM) 154 return; 155 156 // Declare your legalization info 157 DefineLegalizerInfo( 158 A, { getActionDefinitionsBuilder(G_CTLZ_ZERO_UNDEF).libcallFor({s64}); }); 159 // Build 160 auto MIBCTLZ = B.buildInstr(TargetOpcode::G_CTLZ, LLT::scalar(64), Copies[0]); 161 AInfo Info(MF->getSubtarget()); 162 LegalizerHelper Helper(*MF, Info); 163 ASSERT_TRUE(Helper.lower(*MIBCTLZ, 0, LLT::scalar(64)) == 164 LegalizerHelper::LegalizeResult::Legalized); 165 166 auto CheckStr = R"( 167 CHECK: [[CZU:%[0-9]+]]:_(s64) = G_CTLZ_ZERO_UNDEF %0 168 CHECK: [[ZERO:%[0-9]+]]:_(s64) = G_CONSTANT i64 0 169 CHECK: [[THIRTY2:%[0-9]+]]:_(s64) = G_CONSTANT i64 64 170 CHECK: [[CMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), %0:_(s64), [[ZERO]] 171 CHECK: [[SEL:%[0-9]+]]:_(s64) = G_SELECT [[CMP]]:_(s1), [[THIRTY2]]:_, [[CZU]] 172 )"; 173 174 // Check 175 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 176 } 177 178 // CTLZ expansion 179 TEST_F(LegalizerHelperTest, LowerBitCountingCTLZ1) { 180 if (!TM) 181 return; 182 183 // Declare your legalization info 184 DefineLegalizerInfo(A, 185 { getActionDefinitionsBuilder(G_CTPOP).legalFor({s8}); }); 186 // Build 187 // Trunc it to s8. 188 LLT s8{LLT::scalar(8)}; 189 auto MIBTrunc = B.buildTrunc(s8, Copies[0]); 190 auto MIBCTLZ = B.buildInstr(TargetOpcode::G_CTLZ, s8, MIBTrunc); 191 AInfo Info(MF->getSubtarget()); 192 LegalizerHelper Helper(*MF, Info); 193 ASSERT_TRUE(Helper.lower(*MIBCTLZ, 0, s8) == 194 LegalizerHelper::LegalizeResult::Legalized); 195 196 auto CheckStr = R"( 197 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC 198 CHECK: [[Cst1:%[0-9]+]]:_(s8) = G_CONSTANT i8 1 199 CHECK: [[Sh1:%[0-9]+]]:_(s8) = G_LSHR [[Trunc]]:_, [[Cst1]]:_ 200 CHECK: [[Or1:%[0-9]+]]:_(s8) = G_OR [[Trunc]]:_, [[Sh1]]:_ 201 CHECK: [[Cst2:%[0-9]+]]:_(s8) = G_CONSTANT i8 2 202 CHECK: [[Sh2:%[0-9]+]]:_(s8) = G_LSHR [[Or1]]:_, [[Cst2]]:_ 203 CHECK: [[Or2:%[0-9]+]]:_(s8) = G_OR [[Or1]]:_, [[Sh2]]:_ 204 CHECK: [[Cst4:%[0-9]+]]:_(s8) = G_CONSTANT i8 4 205 CHECK: [[Sh4:%[0-9]+]]:_(s8) = G_LSHR [[Or2]]:_, [[Cst4]]:_ 206 CHECK: [[Or4:%[0-9]+]]:_(s8) = G_OR [[Or2]]:_, [[Sh4]]:_ 207 CHECK: [[CTPOP:%[0-9]+]]:_(s8) = G_CTPOP [[Or4]]:_ 208 CHECK: [[Len:%[0-9]+]]:_(s8) = G_CONSTANT i8 8 209 CHECK: [[Sub:%[0-9]+]]:_(s8) = G_SUB [[Len]]:_, [[CTPOP]]:_ 210 )"; 211 212 // Check 213 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 214 } 215 216 // CTLZ widening. 217 TEST_F(LegalizerHelperTest, WidenBitCountingCTLZ) { 218 if (!TM) 219 return; 220 221 // Declare your legalization info 222 DefineLegalizerInfo(A, 223 { getActionDefinitionsBuilder(G_CTLZ).legalFor({s16}); }); 224 // Build 225 // Trunc it to s8. 226 LLT s8{LLT::scalar(8)}; 227 LLT s16{LLT::scalar(16)}; 228 auto MIBTrunc = B.buildTrunc(s8, Copies[0]); 229 auto MIBCTLZ = B.buildInstr(TargetOpcode::G_CTLZ, s8, MIBTrunc); 230 AInfo Info(MF->getSubtarget()); 231 LegalizerHelper Helper(*MF, Info); 232 ASSERT_TRUE(Helper.widenScalar(*MIBCTLZ, 0, s16) == 233 LegalizerHelper::LegalizeResult::Legalized); 234 235 auto CheckStr = R"( 236 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC 237 CHECK: [[Zext:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]] 238 CHECK: [[Ctlz:%[0-9]+]]:_(s16) = G_CTLZ [[Zext]] 239 CHECK: [[Cst8:%[0-9]+]]:_(s16) = G_CONSTANT i16 8 240 CHECK: [[Sub:%[0-9]+]]:_(s16) = G_SUB [[Ctlz]]:_, [[Cst8]]:_ 241 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC [[Sub]] 242 )"; 243 244 // Check 245 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 246 } 247 248 // CTLZ_ZERO_UNDEF widening. 249 TEST_F(LegalizerHelperTest, WidenBitCountingCTLZZeroUndef) { 250 if (!TM) 251 return; 252 253 // Declare your legalization info 254 DefineLegalizerInfo( 255 A, { getActionDefinitionsBuilder(G_CTLZ_ZERO_UNDEF).legalFor({s16}); }); 256 // Build 257 // Trunc it to s8. 258 LLT s8{LLT::scalar(8)}; 259 LLT s16{LLT::scalar(16)}; 260 auto MIBTrunc = B.buildTrunc(s8, Copies[0]); 261 auto MIBCTLZ_ZU = B.buildInstr(TargetOpcode::G_CTLZ_ZERO_UNDEF, s8, MIBTrunc); 262 AInfo Info(MF->getSubtarget()); 263 LegalizerHelper Helper(*MF, Info); 264 ASSERT_TRUE(Helper.widenScalar(*MIBCTLZ_ZU, 0, s16) == 265 LegalizerHelper::LegalizeResult::Legalized); 266 267 auto CheckStr = R"( 268 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC 269 CHECK: [[Zext:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]] 270 CHECK: [[CtlzZu:%[0-9]+]]:_(s16) = G_CTLZ_ZERO_UNDEF [[Zext]] 271 CHECK: [[Cst8:%[0-9]+]]:_(s16) = G_CONSTANT i16 8 272 CHECK: [[Sub:%[0-9]+]]:_(s16) = G_SUB [[CtlzZu]]:_, [[Cst8]]:_ 273 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC [[Sub]] 274 )"; 275 276 // Check 277 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 278 } 279 280 // CTPOP widening. 281 TEST_F(LegalizerHelperTest, WidenBitCountingCTPOP) { 282 if (!TM) 283 return; 284 285 // Declare your legalization info 286 DefineLegalizerInfo( 287 A, { getActionDefinitionsBuilder(G_CTPOP).legalFor({s16}); }); 288 // Build 289 // Trunc it to s8. 290 LLT s8{LLT::scalar(8)}; 291 LLT s16{LLT::scalar(16)}; 292 auto MIBTrunc = B.buildTrunc(s8, Copies[0]); 293 auto MIBCTPOP = B.buildInstr(TargetOpcode::G_CTPOP, s8, MIBTrunc); 294 AInfo Info(MF->getSubtarget()); 295 LegalizerHelper Helper(*MF, Info); 296 ASSERT_TRUE(Helper.widenScalar(*MIBCTPOP, 0, s16) == 297 LegalizerHelper::LegalizeResult::Legalized); 298 299 auto CheckStr = R"( 300 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC 301 CHECK: [[Zext:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]] 302 CHECK: [[Ctpop:%[0-9]+]]:_(s16) = G_CTPOP [[Zext]] 303 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC [[Ctpop]] 304 )"; 305 306 // Check 307 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 308 } 309 310 // CTTZ_ZERO_UNDEF widening. 311 TEST_F(LegalizerHelperTest, WidenBitCountingCTTZ_ZERO_UNDEF) { 312 if (!TM) 313 return; 314 315 // Declare your legalization info 316 DefineLegalizerInfo( 317 A, { getActionDefinitionsBuilder(G_CTTZ_ZERO_UNDEF).legalFor({s16}); }); 318 // Build 319 // Trunc it to s8. 320 LLT s8{LLT::scalar(8)}; 321 LLT s16{LLT::scalar(16)}; 322 auto MIBTrunc = B.buildTrunc(s8, Copies[0]); 323 auto MIBCTTZ_ZERO_UNDEF = 324 B.buildInstr(TargetOpcode::G_CTTZ_ZERO_UNDEF, s8, MIBTrunc); 325 AInfo Info(MF->getSubtarget()); 326 LegalizerHelper Helper(*MF, Info); 327 ASSERT_TRUE(Helper.widenScalar(*MIBCTTZ_ZERO_UNDEF, 0, s16) == 328 LegalizerHelper::LegalizeResult::Legalized); 329 330 auto CheckStr = R"( 331 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC 332 CHECK: [[Zext:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]] 333 CHECK: [[CttzZu:%[0-9]+]]:_(s16) = G_CTTZ_ZERO_UNDEF [[Zext]] 334 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC [[CttzZu]] 335 )"; 336 337 // Check 338 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 339 } 340 341 // CTTZ widening. 342 TEST_F(LegalizerHelperTest, WidenBitCountingCTTZ) { 343 if (!TM) 344 return; 345 346 // Declare your legalization info 347 DefineLegalizerInfo(A, 348 { getActionDefinitionsBuilder(G_CTTZ).legalFor({s16}); }); 349 // Build 350 // Trunc it to s8. 351 LLT s8{LLT::scalar(8)}; 352 LLT s16{LLT::scalar(16)}; 353 auto MIBTrunc = B.buildTrunc(s8, Copies[0]); 354 auto MIBCTTZ = B.buildInstr(TargetOpcode::G_CTTZ, s8, MIBTrunc); 355 AInfo Info(MF->getSubtarget()); 356 LegalizerHelper Helper(*MF, Info); 357 ASSERT_TRUE(Helper.widenScalar(*MIBCTTZ, 0, s16) == 358 LegalizerHelper::LegalizeResult::Legalized); 359 360 auto CheckStr = R"( 361 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC 362 CHECK: [[Zext:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]] 363 CHECK: [[Cst:%[0-9]+]]:_(s16) = G_CONSTANT i16 256 364 CHECK: [[Or:%[0-9]+]]:_(s16) = G_OR [[Zext]]:_, [[Cst]] 365 CHECK: [[Cttz:%[0-9]+]]:_(s16) = G_CTTZ [[Or]] 366 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC [[Cttz]] 367 )"; 368 369 // Check 370 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 371 } 372 // UADDO widening. 373 TEST_F(LegalizerHelperTest, WidenUADDO) { 374 if (!TM) 375 return; 376 377 // Declare your legalization info 378 DefineLegalizerInfo(A, 379 { getActionDefinitionsBuilder(G_ADD).legalFor({s16}); }); 380 // Build 381 // Trunc it to s8. 382 LLT s8{LLT::scalar(8)}; 383 LLT s16{LLT::scalar(16)}; 384 auto MIBTrunc = B.buildTrunc(s8, Copies[0]); 385 unsigned CarryReg = MRI->createGenericVirtualRegister(LLT::scalar(1)); 386 auto MIBUAddO = B.buildInstr(TargetOpcode::G_UADDO, s8) 387 .addDef(CarryReg) 388 .addUse(MIBTrunc->getOperand(0).getReg()) 389 .addUse(MIBTrunc->getOperand(0).getReg()); 390 AInfo Info(MF->getSubtarget()); 391 LegalizerHelper Helper(*MF, Info); 392 ASSERT_TRUE(Helper.widenScalar(*MIBUAddO, 0, s16) == 393 LegalizerHelper::LegalizeResult::Legalized); 394 395 auto CheckStr = R"( 396 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC 397 CHECK: [[LHS:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]] 398 CHECK: [[RHS:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]] 399 CHECK: [[ADD:%[0-9]+]]:_(s16) = G_ADD [[LHS]]:_, [[RHS]]:_ 400 CHECK: [[CST:%[0-9]+]]:_(s16) = G_CONSTANT i16 255 401 CHECK: [[AND:%[0-9]+]]:_(s16) = G_AND [[ADD]]:_, [[CST]]:_ 402 CHECK: G_ICMP intpred(ne), [[ADD]]:_(s16), [[AND]]:_ 403 CHECK: G_TRUNC [[ADD]] 404 )"; 405 406 // Check 407 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 408 } 409 410 // USUBO widening. 411 TEST_F(LegalizerHelperTest, WidenUSUBO) { 412 if (!TM) 413 return; 414 415 // Declare your legalization info 416 DefineLegalizerInfo(A, 417 { getActionDefinitionsBuilder(G_SUB).legalFor({s16}); }); 418 // Build 419 // Trunc it to s8. 420 LLT s8{LLT::scalar(8)}; 421 LLT s16{LLT::scalar(16)}; 422 auto MIBTrunc = B.buildTrunc(s8, Copies[0]); 423 unsigned CarryReg = MRI->createGenericVirtualRegister(LLT::scalar(1)); 424 auto MIBUSUBO = B.buildInstr(TargetOpcode::G_USUBO, s8) 425 .addDef(CarryReg) 426 .addUse(MIBTrunc->getOperand(0).getReg()) 427 .addUse(MIBTrunc->getOperand(0).getReg()); 428 AInfo Info(MF->getSubtarget()); 429 LegalizerHelper Helper(*MF, Info); 430 ASSERT_TRUE(Helper.widenScalar(*MIBUSUBO, 0, s16) == 431 LegalizerHelper::LegalizeResult::Legalized); 432 433 auto CheckStr = R"( 434 CHECK: [[Trunc:%[0-9]+]]:_(s8) = G_TRUNC 435 CHECK: [[LHS:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]] 436 CHECK: [[RHS:%[0-9]+]]:_(s16) = G_ZEXT [[Trunc]] 437 CHECK: [[SUB:%[0-9]+]]:_(s16) = G_SUB [[LHS]]:_, [[RHS]]:_ 438 CHECK: [[CST:%[0-9]+]]:_(s16) = G_CONSTANT i16 255 439 CHECK: [[AND:%[0-9]+]]:_(s16) = G_AND [[SUB]]:_, [[CST]]:_ 440 CHECK: G_ICMP intpred(ne), [[SUB]]:_(s16), [[AND]]:_ 441 CHECK: G_TRUNC [[SUB]] 442 )"; 443 444 // Check 445 ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr)); 446 } 447 } // namespace 448