1161 lines · cpp
1//===- KnownFPClassTest.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-exception6//7//===----------------------------------------------------------------------===//8 9#include "GISelMITest.h"10#include "llvm/ADT/FloatingPointMode.h"11#include "llvm/CodeGen/GlobalISel/GISelValueTracking.h"12#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"13#include "gtest/gtest.h"14#include <optional>15 16TEST_F(AArch64GISelMITest, TestFPClassCstPosZero) {17 StringRef MIRString = " %3:_(s32) = G_FCONSTANT float 0.0\n"18 " %4:_(s32) = COPY %3\n";19 setUp(MIRString);20 if (!TM)21 GTEST_SKIP();22 unsigned CopyReg = Copies[Copies.size() - 1];23 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);24 Register SrcReg = FinalCopy->getOperand(1).getReg();25 26 GISelValueTracking Info(*MF);27 28 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);29 30 EXPECT_EQ(fcPosZero, Known.KnownFPClasses);31 EXPECT_EQ(false, Known.SignBit);32}33 34TEST_F(AArch64GISelMITest, TestFPClassCstNegZero) {35 StringRef MIRString = " %3:_(s32) = G_FCONSTANT float -0.0\n"36 " %4:_(s32) = COPY %3\n";37 setUp(MIRString);38 if (!TM)39 GTEST_SKIP();40 Register CopyReg = Copies[Copies.size() - 1];41 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);42 Register SrcReg = FinalCopy->getOperand(1).getReg();43 44 GISelValueTracking Info(*MF);45 46 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);47 48 EXPECT_EQ(fcNegZero, Known.KnownFPClasses);49 EXPECT_EQ(true, Known.SignBit);50}51 52TEST_F(AArch64GISelMITest, TestFPClassUndef) {53 StringRef MIRString = R"(54 %def:_(s32) = G_IMPLICIT_DEF55 %copy_def:_(s32) = COPY %def56)";57 58 setUp(MIRString);59 if (!TM)60 GTEST_SKIP();61 62 Register CopyReg = Copies[Copies.size() - 1];63 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);64 Register SrcReg = FinalCopy->getOperand(1).getReg();65 66 GISelValueTracking Info(*MF);67 68 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);69 70 EXPECT_EQ(fcAllFlags, Known.KnownFPClasses);71 EXPECT_EQ(std::nullopt, Known.SignBit);72}73 74TEST_F(AArch64GISelMITest, TestFPClassCstVecNegZero) {75 StringRef MIRString = R"(76 %c0:_(s32) = G_FCONSTANT float -0.077 %c1:_(s32) = G_FCONSTANT float -0.078 %c2:_(s32) = G_FCONSTANT float -0.079 %vector:_(<3 x s32>) = G_BUILD_VECTOR %c0, %c1, %c280 %copy_vector:_(<3 x s32>) = COPY %vector81)";82 83 setUp(MIRString);84 if (!TM)85 GTEST_SKIP();86 87 Register CopyReg = Copies[Copies.size() - 1];88 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);89 Register SrcReg = FinalCopy->getOperand(1).getReg();90 91 GISelValueTracking Info(*MF);92 93 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);94 95 EXPECT_EQ(fcNegZero, Known.KnownFPClasses);96 EXPECT_EQ(true, Known.SignBit);97}98 99TEST_F(AArch64GISelMITest, TestFPClassCstZeroFPExt) {100 StringRef MIRString = R"(101 %c0:_(s32) = G_FCONSTANT float 0.0102 %ext:_(s64) = nnan ninf G_FPEXT %c0103 %copy_vector:_(s64) = COPY %ext104)";105 106 setUp(MIRString);107 if (!TM)108 GTEST_SKIP();109 110 Register CopyReg = Copies[Copies.size() - 1];111 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);112 Register SrcReg = FinalCopy->getOperand(1).getReg();113 114 GISelValueTracking Info(*MF);115 116 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);117 118 EXPECT_EQ(fcZero | fcNormal, Known.KnownFPClasses);119 EXPECT_EQ(std::nullopt, Known.SignBit);120}121 122TEST_F(AArch64GISelMITest, TestFPClassCstVecZeroFPExt) {123 StringRef MIRString = R"(124 %c0:_(s32) = G_FCONSTANT float 0.0125 %c1:_(s32) = G_FCONSTANT float 0.0126 %c2:_(s32) = G_FCONSTANT float 0.0127 %vector:_(<3 x s32>) = G_BUILD_VECTOR %c0, %c1, %c2128 %ext:_(<3 x s64>) = nnan ninf G_FPEXT %vector129 %copy_vector:_(<3 x s64>) = COPY %ext130)";131 132 setUp(MIRString);133 if (!TM)134 GTEST_SKIP();135 136 Register CopyReg = Copies[Copies.size() - 1];137 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);138 Register SrcReg = FinalCopy->getOperand(1).getReg();139 140 GISelValueTracking Info(*MF);141 142 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);143 144 EXPECT_EQ(fcZero | fcNormal, Known.KnownFPClasses);145 EXPECT_EQ(std::nullopt, Known.SignBit);146}147 148TEST_F(AArch64GISelMITest, TestFPClassCstZeroFPTrunc) {149 StringRef MIRString = R"(150 %c0:_(s64) = G_FCONSTANT double 0.0151 %trunc:_(s32) = nnan ninf G_FPTRUNC %c0152 %copy_vector:_(s32) = COPY %trunc153)";154 155 setUp(MIRString);156 if (!TM)157 GTEST_SKIP();158 159 Register CopyReg = Copies[Copies.size() - 1];160 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);161 Register SrcReg = FinalCopy->getOperand(1).getReg();162 163 GISelValueTracking Info(*MF);164 165 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);166 167 EXPECT_EQ(fcZero | fcPosSubnormal | fcPosNormal, Known.KnownFPClasses);168 EXPECT_EQ(false, Known.SignBit);169}170 171TEST_F(AArch64GISelMITest, TestFPClassCstVecZeroFPTrunc) {172 StringRef MIRString = R"(173 %c0:_(s64) = G_FCONSTANT double 0.0174 %c1:_(s64) = G_FCONSTANT double 0.0175 %c2:_(s64) = G_FCONSTANT double 0.0176 %vector:_(<3 x s64>) = G_BUILD_VECTOR %c0, %c1, %c2177 %trunc:_(<3 x s32>) = nnan ninf G_FPTRUNC %vector178 %copy_vector:_(<3 x s32>) = COPY %trunc179)";180 181 setUp(MIRString);182 if (!TM)183 GTEST_SKIP();184 185 Register CopyReg = Copies[Copies.size() - 1];186 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);187 Register SrcReg = FinalCopy->getOperand(1).getReg();188 189 GISelValueTracking Info(*MF);190 191 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);192 193 EXPECT_EQ(fcZero | fcPosSubnormal | fcPosNormal, Known.KnownFPClasses);194 EXPECT_EQ(false, Known.SignBit);195}196 197TEST_F(AArch64GISelMITest, TestFPClassSelectPos0) {198 StringRef MIRString = R"(199 %ptr:_(p0) = G_IMPLICIT_DEF200 %cond:_(s1) = G_LOAD %ptr(p0) :: (load (s1))201 %lhs:_(s32) = G_FCONSTANT float 0.0202 %rhs:_(s32) = G_FCONSTANT float 0.0203 %sel:_(s32) = G_SELECT %cond, %lhs, %rhs204 %copy_sel:_(s32) = COPY %sel205)";206 207 setUp(MIRString);208 if (!TM)209 GTEST_SKIP();210 211 Register CopyReg = Copies[Copies.size() - 1];212 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);213 Register SrcReg = FinalCopy->getOperand(1).getReg();214 215 GISelValueTracking Info(*MF);216 217 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);218 219 EXPECT_EQ(fcPosZero, Known.KnownFPClasses);220 EXPECT_EQ(false, Known.SignBit);221}222 223TEST_F(AArch64GISelMITest, TestFPClassSelectNeg0) {224 StringRef MIRString = R"(225 %ptr:_(p0) = G_IMPLICIT_DEF226 %cond:_(s1) = G_LOAD %ptr(p0) :: (load (s1))227 %lhs:_(s32) = G_FCONSTANT float -0.0228 %rhs:_(s32) = G_FCONSTANT float -0.0229 %sel:_(s32) = G_SELECT %cond, %lhs, %rhs230 %copy_sel:_(s32) = COPY %sel231)";232 233 setUp(MIRString);234 if (!TM)235 GTEST_SKIP();236 237 Register CopyReg = Copies[Copies.size() - 1];238 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);239 Register SrcReg = FinalCopy->getOperand(1).getReg();240 241 GISelValueTracking Info(*MF);242 243 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);244 245 EXPECT_EQ(fcNegZero, Known.KnownFPClasses);246 EXPECT_EQ(true, Known.SignBit);247}248 249TEST_F(AArch64GISelMITest, TestFPClassSelectPosOrNeg0) {250 StringRef MIRString = R"(251 %ptr:_(p0) = G_IMPLICIT_DEF252 %cond:_(s1) = G_LOAD %ptr(p0) :: (load (s1))253 %lhs:_(s32) = G_FCONSTANT float -0.0254 %rhs:_(s32) = G_FCONSTANT float 0.0255 %sel:_(s32) = G_SELECT %cond, %lhs, %rhs256 %copy_sel:_(s32) = COPY %sel257)";258 259 setUp(MIRString);260 if (!TM)261 GTEST_SKIP();262 263 Register CopyReg = Copies[Copies.size() - 1];264 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);265 Register SrcReg = FinalCopy->getOperand(1).getReg();266 267 GISelValueTracking Info(*MF);268 269 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);270 271 EXPECT_EQ(fcZero, Known.KnownFPClasses);272 EXPECT_EQ(std::nullopt, Known.SignBit);273}274 275TEST_F(AArch64GISelMITest, TestFPClassSelectPosInf) {276 StringRef MIRString = R"(277 %ptr:_(p0) = G_IMPLICIT_DEF278 %cond:_(s1) = G_LOAD %ptr(p0) :: (load (s1))279 %lhs:_(s32) = G_FCONSTANT float 0x7FF0000000000000280 %rhs:_(s32) = G_FCONSTANT float 0x7FF0000000000000281 %sel:_(s32) = G_SELECT %cond, %lhs, %rhs282 %copy_sel:_(s32) = COPY %sel283)";284 285 setUp(MIRString);286 if (!TM)287 GTEST_SKIP();288 289 Register CopyReg = Copies[Copies.size() - 1];290 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);291 Register SrcReg = FinalCopy->getOperand(1).getReg();292 293 GISelValueTracking Info(*MF);294 295 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);296 297 EXPECT_EQ(fcPosInf, Known.KnownFPClasses);298 EXPECT_EQ(false, Known.SignBit);299}300 301TEST_F(AArch64GISelMITest, TestFPClassSelectNegInf) {302 StringRef MIRString = R"(303 %ptr:_(p0) = G_IMPLICIT_DEF304 %cond:_(s1) = G_LOAD %ptr(p0) :: (load (s1))305 %lhs:_(s32) = G_FCONSTANT float 0xFFF0000000000000306 %rhs:_(s32) = G_FCONSTANT float 0xFFF0000000000000307 %sel:_(s32) = G_SELECT %cond, %lhs, %rhs308 %copy_sel:_(s32) = COPY %sel309)";310 311 setUp(MIRString);312 if (!TM)313 GTEST_SKIP();314 315 Register CopyReg = Copies[Copies.size() - 1];316 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);317 Register SrcReg = FinalCopy->getOperand(1).getReg();318 319 GISelValueTracking Info(*MF);320 321 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);322 323 EXPECT_EQ(fcNegInf, Known.KnownFPClasses);324 EXPECT_EQ(true, Known.SignBit);325}326 327TEST_F(AArch64GISelMITest, TestFPClassSelectPosOrNegInf) {328 StringRef MIRString = R"(329 %ptr:_(p0) = G_IMPLICIT_DEF330 %cond:_(s1) = G_LOAD %ptr(p0) :: (load (s1))331 %lhs:_(s32) = G_FCONSTANT float 0x7FF0000000000000332 %rhs:_(s32) = G_FCONSTANT float 0xFFF0000000000000333 %sel:_(s32) = G_SELECT %cond, %lhs, %rhs334 %copy_sel:_(s32) = COPY %sel335)";336 337 setUp(MIRString);338 if (!TM)339 GTEST_SKIP();340 341 Register CopyReg = Copies[Copies.size() - 1];342 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);343 Register SrcReg = FinalCopy->getOperand(1).getReg();344 345 GISelValueTracking Info(*MF);346 347 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);348 349 EXPECT_EQ(fcInf, Known.KnownFPClasses);350 EXPECT_EQ(std::nullopt, Known.SignBit);351}352 353TEST_F(AArch64GISelMITest, TestFPClassSelectNNaN) {354 StringRef MIRString = R"(355 %ptr:_(p0) = G_IMPLICIT_DEF356 %cond:_(s1) = G_LOAD %ptr(p0) :: (load (s1))357 %lhs:_(s32) = G_LOAD %ptr(p0) :: (load (s32))358 %rhs:_(s32) = G_LOAD %ptr(p0) :: (load (s32))359 %sel:_(s32) = nnan G_SELECT %cond, %lhs, %rhs360 %copy_sel:_(s32) = COPY %sel361)";362 363 setUp(MIRString);364 if (!TM)365 GTEST_SKIP();366 367 Register CopyReg = Copies[Copies.size() - 1];368 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);369 Register SrcReg = FinalCopy->getOperand(1).getReg();370 371 GISelValueTracking Info(*MF);372 373 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);374 375 EXPECT_EQ(~fcNan, Known.KnownFPClasses);376 EXPECT_EQ(std::nullopt, Known.SignBit);377}378 379TEST_F(AArch64GISelMITest, TestFPClassSelectNInf) {380 StringRef MIRString = R"(381 %ptr:_(p0) = G_IMPLICIT_DEF382 %cond:_(s1) = G_LOAD %ptr(p0) :: (load (s1))383 %lhs:_(s32) = G_LOAD %ptr(p0) :: (load (s32))384 %rhs:_(s32) = G_LOAD %ptr(p0) :: (load (s32))385 %sel:_(s32) = ninf G_SELECT %cond, %lhs, %rhs386 %copy_sel:_(s32) = COPY %sel387)";388 389 setUp(MIRString);390 if (!TM)391 GTEST_SKIP();392 393 Register CopyReg = Copies[Copies.size() - 1];394 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);395 Register SrcReg = FinalCopy->getOperand(1).getReg();396 397 GISelValueTracking Info(*MF);398 399 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);400 401 EXPECT_EQ(~fcInf, Known.KnownFPClasses);402 EXPECT_EQ(std::nullopt, Known.SignBit);403}404 405TEST_F(AArch64GISelMITest, TestFPClassSelectNNaNNInf) {406 StringRef MIRString = R"(407 %ptr:_(p0) = G_IMPLICIT_DEF408 %cond:_(s1) = G_LOAD %ptr(p0) :: (load (s1))409 %lhs:_(s32) = G_LOAD %ptr(p0) :: (load (s32))410 %rhs:_(s32) = G_LOAD %ptr(p0) :: (load (s32))411 %sel:_(s32) = nnan ninf G_SELECT %cond, %lhs, %rhs412 %copy_sel:_(s32) = COPY %sel413)";414 415 setUp(MIRString);416 if (!TM)417 GTEST_SKIP();418 419 Register CopyReg = Copies[Copies.size() - 1];420 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);421 Register SrcReg = FinalCopy->getOperand(1).getReg();422 423 GISelValueTracking Info(*MF);424 425 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);426 427 EXPECT_EQ(~(fcNan | fcInf), Known.KnownFPClasses);428 EXPECT_EQ(std::nullopt, Known.SignBit);429}430 431TEST_F(AArch64GISelMITest, TestFPClassFNegNInf) {432 StringRef MIRString = R"(433 %ptr:_(p0) = G_IMPLICIT_DEF434 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))435 %fneg:_(s32) = ninf G_FNEG %val436 %copy_fneg:_(s32) = COPY %fneg437)";438 439 setUp(MIRString);440 if (!TM)441 GTEST_SKIP();442 443 Register CopyReg = Copies[Copies.size() - 1];444 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);445 Register SrcReg = FinalCopy->getOperand(1).getReg();446 447 GISelValueTracking Info(*MF);448 449 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);450 451 EXPECT_EQ(~fcInf, Known.KnownFPClasses);452 EXPECT_EQ(std::nullopt, Known.SignBit);453}454 455TEST_F(AArch64GISelMITest, TestFPClassFabsUnknown) {456 StringRef MIRString = R"(457 %ptr:_(p0) = G_IMPLICIT_DEF458 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))459 %fabs:_(s32) = G_FABS %val460 %copy_fabs:_(s32) = COPY %fabs461)";462 463 setUp(MIRString);464 if (!TM)465 GTEST_SKIP();466 467 Register CopyReg = Copies[Copies.size() - 1];468 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);469 Register SrcReg = FinalCopy->getOperand(1).getReg();470 471 GISelValueTracking Info(*MF);472 473 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);474 475 EXPECT_EQ(fcPositive | fcNan, Known.KnownFPClasses);476 EXPECT_EQ(false, Known.SignBit);477}478 479TEST_F(AArch64GISelMITest, TestFPClassVecFabsUnknown) {480 StringRef MIRString = R"(481 %ptr:_(p0) = G_IMPLICIT_DEF482 %val:_(<3 x s32>) = G_LOAD %ptr(p0) :: (load (<3 x s32>))483 %fabs:_(<3 x s32>) = G_FABS %val484 %copy_fabs:_(<3 x s32>) = COPY %fabs485)";486 487 setUp(MIRString);488 if (!TM)489 GTEST_SKIP();490 491 Register CopyReg = Copies[Copies.size() - 1];492 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);493 Register SrcReg = FinalCopy->getOperand(1).getReg();494 495 GISelValueTracking Info(*MF);496 497 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);498 499 EXPECT_EQ(fcPositive | fcNan, Known.KnownFPClasses);500 EXPECT_EQ(false, Known.SignBit);501}502 503TEST_F(AArch64GISelMITest, TestFPClassFnegFabs) {504 StringRef MIRString = R"(505 %ptr:_(p0) = G_IMPLICIT_DEF506 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))507 %fabs:_(s32) = G_FABS %val508 %fneg:_(s32) = G_FNEG %fabs509 %copy_fneg:_(s32) = COPY %fneg510)";511 512 setUp(MIRString);513 if (!TM)514 GTEST_SKIP();515 516 Register CopyReg = Copies[Copies.size() - 1];517 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);518 Register SrcReg = FinalCopy->getOperand(1).getReg();519 520 GISelValueTracking Info(*MF);521 522 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);523 524 EXPECT_EQ(fcNegative | fcNan, Known.KnownFPClasses);525 EXPECT_EQ(true, Known.SignBit);526}527 528TEST_F(AArch64GISelMITest, TestFPClassFnegFabsNInf) {529 StringRef MIRString = R"(530 %ptr:_(p0) = G_IMPLICIT_DEF531 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))532 %fabs:_(s32) = ninf G_FABS %val533 %fneg:_(s32) = G_FNEG %fabs534 %copy_fneg:_(s32) = COPY %fneg535)";536 537 setUp(MIRString);538 if (!TM)539 GTEST_SKIP();540 541 Register CopyReg = Copies[Copies.size() - 1];542 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);543 Register SrcReg = FinalCopy->getOperand(1).getReg();544 545 GISelValueTracking Info(*MF);546 547 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);548 549 EXPECT_EQ((fcNegative & ~fcNegInf) | fcNan, Known.KnownFPClasses);550 EXPECT_EQ(true, Known.SignBit);551}552 553TEST_F(AArch64GISelMITest, TestFPClassFnegFabsNNan) {554 StringRef MIRString = R"(555 %ptr:_(p0) = G_IMPLICIT_DEF556 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))557 %fabs:_(s32) = nnan G_FABS %val558 %fneg:_(s32) = G_FNEG %fabs559 %copy_fneg:_(s32) = COPY %fneg560)";561 562 setUp(MIRString);563 if (!TM)564 GTEST_SKIP();565 566 Register CopyReg = Copies[Copies.size() - 1];567 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);568 Register SrcReg = FinalCopy->getOperand(1).getReg();569 570 GISelValueTracking Info(*MF);571 572 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);573 574 EXPECT_EQ(fcNegative, Known.KnownFPClasses);575 EXPECT_EQ(true, Known.SignBit);576}577 578TEST_F(AArch64GISelMITest, TestFPClassCopySignNNanSrc0) {579 StringRef MIRString = R"(580 %ptr:_(p0) = G_IMPLICIT_DEF581 %mag:_(s32) = G_LOAD %ptr(p0) :: (load (s32))582 %sgn:_(s32) = G_LOAD %ptr(p0) :: (load (s32))583 %fabs:_(s32) = nnan G_FABS %mag584 %fcopysign:_(s32) = G_FCOPYSIGN %fabs, %sgn585 %copy_fcopysign:_(s32) = COPY %fcopysign586)";587 588 setUp(MIRString);589 if (!TM)590 GTEST_SKIP();591 592 Register CopyReg = Copies[Copies.size() - 1];593 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);594 Register SrcReg = FinalCopy->getOperand(1).getReg();595 596 GISelValueTracking Info(*MF);597 598 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);599 600 EXPECT_EQ(~fcNan, Known.KnownFPClasses);601 EXPECT_EQ(std::nullopt, Known.SignBit);602}603 604TEST_F(AArch64GISelMITest, TestFPClassCopySignNInfSrc0_NegSign) {605 StringRef MIRString = R"(606 %ptr:_(p0) = G_IMPLICIT_DEF607 %mag:_(s32) = G_LOAD %ptr(p0) :: (load (s32))608 %sgn:_(s32) = G_FCONSTANT float -1.0609 %fabs:_(s32) = ninf G_FLOG %mag610 %fcopysign:_(s32) = G_FCOPYSIGN %fabs, %sgn611 %copy_fcopysign:_(s32) = COPY %fcopysign612)";613 614 setUp(MIRString);615 if (!TM)616 GTEST_SKIP();617 618 Register CopyReg = Copies[Copies.size() - 1];619 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);620 Register SrcReg = FinalCopy->getOperand(1).getReg();621 622 GISelValueTracking Info(*MF);623 624 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);625 626 EXPECT_EQ(fcNegFinite | fcNan, Known.KnownFPClasses);627 EXPECT_EQ(true, Known.SignBit);628}629 630TEST_F(AArch64GISelMITest, TestFPClassCopySignNInfSrc0_PosSign) {631 StringRef MIRString = R"(632 %ptr:_(p0) = G_IMPLICIT_DEF633 %mag:_(s32) = G_LOAD %ptr(p0) :: (load (s32))634 %sgn:_(s32) = G_FCONSTANT float 1.0635 %fabs:_(s32) = ninf G_FSQRT %mag636 %fcopysign:_(s32) = G_FCOPYSIGN %fabs, %sgn637 %copy_fcopysign:_(s32) = COPY %fcopysign638)";639 640 setUp(MIRString);641 if (!TM)642 GTEST_SKIP();643 644 Register CopyReg = Copies[Copies.size() - 1];645 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);646 Register SrcReg = FinalCopy->getOperand(1).getReg();647 648 GISelValueTracking Info(*MF);649 650 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);651 652 EXPECT_EQ(fcPosFinite | fcNan, Known.KnownFPClasses);653 EXPECT_EQ(false, Known.SignBit);654}655 656TEST_F(AArch64GISelMITest, TestFPClassUIToFP) {657 StringRef MIRString = R"(658 %ptr:_(p0) = G_IMPLICIT_DEF659 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))660 %cast:_(s32) = G_UITOFP %val661 %copy_cast:_(s32) = COPY %cast662)";663 664 setUp(MIRString);665 if (!TM)666 GTEST_SKIP();667 668 Register CopyReg = Copies[Copies.size() - 1];669 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);670 Register SrcReg = FinalCopy->getOperand(1).getReg();671 672 GISelValueTracking Info(*MF);673 674 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);675 676 EXPECT_EQ(fcPosFinite & ~fcSubnormal, Known.KnownFPClasses);677 EXPECT_EQ(false, Known.SignBit);678}679 680TEST_F(AArch64GISelMITest, TestFPClassSIToFP) {681 StringRef MIRString = R"(682 %ptr:_(p0) = G_IMPLICIT_DEF683 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))684 %cast:_(s32) = G_SITOFP %val685 %copy_cast:_(s32) = COPY %cast686)";687 688 setUp(MIRString);689 if (!TM)690 GTEST_SKIP();691 692 Register CopyReg = Copies[Copies.size() - 1];693 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);694 Register SrcReg = FinalCopy->getOperand(1).getReg();695 696 GISelValueTracking Info(*MF);697 698 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);699 700 EXPECT_EQ(fcFinite & ~fcNegZero & ~fcSubnormal, Known.KnownFPClasses);701 EXPECT_EQ(std::nullopt, Known.SignBit);702}703 704TEST_F(AArch64GISelMITest, TestFPClassFAdd) {705 StringRef MIRString = R"(706 %ptr:_(p0) = G_IMPLICIT_DEF707 %lhs:_(s32) = G_LOAD %ptr(p0) :: (load (s32))708 %rhs:_(s32) = G_LOAD %ptr(p0) :: (load (s32))709 %fadd:_(s32) = G_FADD %lhs, %rhs710 %copy_fadd:_(s32) = COPY %fadd711)";712 713 setUp(MIRString);714 if (!TM)715 GTEST_SKIP();716 717 Register CopyReg = Copies[Copies.size() - 1];718 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);719 Register SrcReg = FinalCopy->getOperand(1).getReg();720 721 GISelValueTracking Info(*MF);722 723 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);724 725 EXPECT_EQ(fcAllFlags, Known.KnownFPClasses);726 EXPECT_EQ(std::nullopt, Known.SignBit);727}728 729TEST_F(AArch64GISelMITest, TestFPClassFMul) {730 StringRef MIRString = R"(731 %ptr:_(p0) = G_IMPLICIT_DEF732 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))733 %fmul:_(s32) = G_FMUL %val, %val734 %copy_fadd:_(s32) = COPY %fmul735)";736 737 setUp(MIRString);738 if (!TM)739 GTEST_SKIP();740 741 Register CopyReg = Copies[Copies.size() - 1];742 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);743 Register SrcReg = FinalCopy->getOperand(1).getReg();744 745 GISelValueTracking Info(*MF);746 747 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);748 749 EXPECT_EQ(fcPositive | fcNan, Known.KnownFPClasses);750 EXPECT_EQ(std::nullopt, Known.SignBit);751}752 753TEST_F(AArch64GISelMITest, TestFPClassFMulZero) {754 StringRef MIRString = R"(755 %ptr:_(p0) = G_IMPLICIT_DEF756 %lhs:_(s32) = G_LOAD %ptr(p0) :: (load (s32))757 %rhs:_(s32) = G_FCONSTANT float 0.0758 %fabs:_(s32) = nnan ninf G_FABS %lhs759 %fmul:_(s32) = G_FMUL %fabs, %rhs760 %copy_fadd:_(s32) = COPY %fmul761)";762 763 setUp(MIRString);764 if (!TM)765 GTEST_SKIP();766 767 Register CopyReg = Copies[Copies.size() - 1];768 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);769 Register SrcReg = FinalCopy->getOperand(1).getReg();770 771 GISelValueTracking Info(*MF);772 773 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);774 775 EXPECT_EQ(fcPositive, Known.KnownFPClasses);776 EXPECT_EQ(false, Known.SignBit);777}778 779TEST_F(AArch64GISelMITest, TestFPClassFLogNeg) {780 StringRef MIRString = R"(781 %ptr:_(p0) = G_IMPLICIT_DEF782 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))783 %fabs:_(s32) = nnan ninf G_FABS %val784 %fneg:_(s32) = nnan ninf G_FNEG %fabs785 %flog:_(s32) = G_FLOG %fneg786 %copy_flog:_(s32) = COPY %flog787)";788 789 setUp(MIRString);790 if (!TM)791 GTEST_SKIP();792 793 Register CopyReg = Copies[Copies.size() - 1];794 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);795 Register SrcReg = FinalCopy->getOperand(1).getReg();796 797 GISelValueTracking Info(*MF);798 799 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);800 801 EXPECT_EQ(fcFinite | fcNan | fcNegInf, Known.KnownFPClasses);802 EXPECT_EQ(std::nullopt, Known.SignBit);803}804 805TEST_F(AArch64GISelMITest, TestFPClassFLogPosZero) {806 StringRef MIRString = R"(807 %val:_(s32) = G_FCONSTANT float 0.0808 %flog:_(s32) = G_FLOG %val809 %copy_flog:_(s32) = COPY %flog810)";811 812 setUp(MIRString);813 if (!TM)814 GTEST_SKIP();815 816 Register CopyReg = Copies[Copies.size() - 1];817 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);818 Register SrcReg = FinalCopy->getOperand(1).getReg();819 820 GISelValueTracking Info(*MF);821 822 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);823 824 EXPECT_EQ(fcFinite | fcNegInf, Known.KnownFPClasses);825 EXPECT_EQ(std::nullopt, Known.SignBit);826}827 828TEST_F(AArch64GISelMITest, TestFPClassFLogNegZero) {829 StringRef MIRString = R"(830 %val:_(s32) = G_FCONSTANT float -0.0831 %flog:_(s32) = G_FLOG %val832 %copy_flog:_(s32) = COPY %flog833)";834 835 setUp(MIRString);836 if (!TM)837 GTEST_SKIP();838 839 Register CopyReg = Copies[Copies.size() - 1];840 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);841 Register SrcReg = FinalCopy->getOperand(1).getReg();842 843 GISelValueTracking Info(*MF);844 845 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);846 847 EXPECT_EQ(fcFinite | fcNegInf, Known.KnownFPClasses);848 EXPECT_EQ(std::nullopt, Known.SignBit);849}850 851TEST_F(AArch64GISelMITest, TestFPClassCopy) {852 StringRef MIRString = R"(853 %ptr:_(p0) = G_IMPLICIT_DEF854 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))855 %fabs:_(s32) = G_FABS %val856 %copy:_(s32) = COPY %fabs857 %copy_copy:_(s32) = COPY %copy858)";859 860 setUp(MIRString);861 if (!TM)862 GTEST_SKIP();863 864 Register CopyReg = Copies[Copies.size() - 1];865 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);866 Register SrcReg = FinalCopy->getOperand(1).getReg();867 868 GISelValueTracking Info(*MF);869 870 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);871 872 EXPECT_EQ(fcPositive | fcNan, Known.KnownFPClasses);873 EXPECT_EQ(false, Known.SignBit);874}875 876TEST_F(AArch64GISelMITest, TestFPClassSelectIsFPClass) {877 StringRef MIRString = R"(878 %ptr:_(p0) = G_IMPLICIT_DEF879 %lhs:_(s32) = G_LOAD %ptr(p0) :: (load (s32))880 %rhs:_(s32) = G_FCONSTANT float 0.0881 %cond:_(s1) = G_IS_FPCLASS %lhs, 96882 %sel:_(s32) = G_SELECT %cond, %lhs, %rhs 883 %copy_sel:_(s32) = COPY %sel884)";885 886 setUp(MIRString);887 if (!TM)888 GTEST_SKIP();889 890 Register CopyReg = Copies[Copies.size() - 1];891 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);892 Register SrcReg = FinalCopy->getOperand(1).getReg();893 894 GISelValueTracking Info(*MF);895 896 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);897 898 EXPECT_EQ(fcZero, Known.KnownFPClasses);899 EXPECT_EQ(std::nullopt, Known.SignBit);900}901 902TEST_F(AArch64GISelMITest, TestFPClassFLDExp) {903 StringRef MIRString = R"(904 %ptr:_(p0) = G_IMPLICIT_DEF905 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))906 %exp:_(s32) = G_LOAD %ptr(p0) :: (load (s32))907 %fabs:_(s32) = G_FABS %val908 %fldexp:_(s32) = G_FLDEXP %fabs, %exp909 %copy_fldexp:_(s32) = COPY %fldexp910)";911 912 setUp(MIRString);913 if (!TM)914 GTEST_SKIP();915 916 Register CopyReg = Copies[Copies.size() - 1];917 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);918 Register SrcReg = FinalCopy->getOperand(1).getReg();919 920 GISelValueTracking Info(*MF);921 922 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);923 924 EXPECT_EQ(fcPositive | fcNan, Known.KnownFPClasses);925 EXPECT_EQ(std::nullopt, Known.SignBit);926}927 928TEST_F(AArch64GISelMITest, TestFPClassFPowIEvenExp) {929 StringRef MIRString = R"(930 %ptr:_(p0) = G_IMPLICIT_DEF931 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))932 %pwr:_(s32) = G_CONSTANT i32 2933 %fpowi:_(s32) = G_FPOWI %val, %pwr934 %copy_fpowi:_(s32) = COPY %fpowi935)";936 937 setUp(MIRString);938 if (!TM)939 GTEST_SKIP();940 941 Register CopyReg = Copies[Copies.size() - 1];942 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);943 Register SrcReg = FinalCopy->getOperand(1).getReg();944 945 GISelValueTracking Info(*MF);946 947 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);948 949 EXPECT_EQ(fcPositive | fcNan, Known.KnownFPClasses);950 EXPECT_EQ(std::nullopt, Known.SignBit);951}952 953TEST_F(AArch64GISelMITest, TestFPClassFPowIPos) {954 StringRef MIRString = R"(955 %ptr:_(p0) = G_IMPLICIT_DEF956 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))957 %pwr:_(s32) = G_CONSTANT i32 3958 %fabs:_(s32) = nnan ninf G_FABS %val959 %fpowi:_(s32) = G_FPOWI %fabs, %pwr960 %copy_fpowi:_(s32) = COPY %fpowi961)";962 963 setUp(MIRString);964 if (!TM)965 GTEST_SKIP();966 967 Register CopyReg = Copies[Copies.size() - 1];968 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);969 Register SrcReg = FinalCopy->getOperand(1).getReg();970 971 GISelValueTracking Info(*MF);972 973 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);974 975 EXPECT_EQ(fcPositive | fcNan, Known.KnownFPClasses);976 EXPECT_EQ(std::nullopt, Known.SignBit);977}978 979TEST_F(AArch64GISelMITest, TestFPClassFDiv) {980 StringRef MIRString = R"(981 %ptr:_(p0) = G_IMPLICIT_DEF982 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))983 %fdiv:_(s32) = G_FDIV %val, %val984 %copy_fdiv:_(s32) = COPY %fdiv985)";986 987 setUp(MIRString);988 if (!TM)989 GTEST_SKIP();990 991 Register CopyReg = Copies[Copies.size() - 1];992 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);993 Register SrcReg = FinalCopy->getOperand(1).getReg();994 995 GISelValueTracking Info(*MF);996 997 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);998 999 EXPECT_EQ(fcPosNormal | fcNan, Known.KnownFPClasses);1000 EXPECT_EQ(std::nullopt, Known.SignBit);1001}1002 1003TEST_F(AArch64GISelMITest, TestFPClassFRem) {1004 StringRef MIRString = R"(1005 %ptr:_(p0) = G_IMPLICIT_DEF1006 %val:_(s32) = G_LOAD %ptr(p0) :: (load (s32))1007 %frem:_(s32) = G_FREM %val, %val1008 %copy_frem:_(s32) = COPY %frem1009)";1010 1011 setUp(MIRString);1012 if (!TM)1013 GTEST_SKIP();1014 1015 Register CopyReg = Copies[Copies.size() - 1];1016 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);1017 Register SrcReg = FinalCopy->getOperand(1).getReg();1018 1019 GISelValueTracking Info(*MF);1020 1021 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);1022 1023 EXPECT_EQ(fcZero | fcNan, Known.KnownFPClasses);1024 EXPECT_EQ(std::nullopt, Known.SignBit);1025}1026 1027TEST_F(AArch64GISelMITest, TestFPClassShuffleVec) {1028 StringRef MIRString = R"(1029 %ptr:_(p0) = G_IMPLICIT_DEF1030 %vec:_(<4 x s32>) = G_LOAD %ptr(p0) :: (load (<4 x s32>))1031 %fabs:_(<4 x s32>) = nnan ninf G_FABS %vec1032 %def:_(<4 x s32>) = G_IMPLICIT_DEF1033 %shuf:_(<4 x s32>) = G_SHUFFLE_VECTOR %fabs(<4 x s32>), %def, shufflemask(0, 0, 0, 0)1034 %copy_shuf:_(<4 x s32>) = COPY %shuf1035)";1036 1037 setUp(MIRString);1038 if (!TM)1039 GTEST_SKIP();1040 1041 Register CopyReg = Copies[Copies.size() - 1];1042 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);1043 Register SrcReg = FinalCopy->getOperand(1).getReg();1044 1045 GISelValueTracking Info(*MF);1046 1047 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);1048 1049 EXPECT_EQ(fcPosFinite, Known.KnownFPClasses);1050 EXPECT_EQ(false, Known.SignBit);1051}1052 1053TEST_F(AArch64GISelMITest, TestFPClassBuildVec) {1054 StringRef MIRString = R"(1055 %ptr:_(p0) = G_IMPLICIT_DEF1056 %val1:_(s32) = G_LOAD %ptr(p0) :: (load (s32))1057 %fabs:_(s32) = nnan ninf G_FABS %val11058 %val2:_(s32) = G_FCONSTANT float 3.01059 %vec:_(<2 x s32>) = G_BUILD_VECTOR %fabs, %val21060 %copy_vec:_(<2 x s32>) = COPY %vec1061)";1062 1063 setUp(MIRString);1064 if (!TM)1065 GTEST_SKIP();1066 1067 Register CopyReg = Copies[Copies.size() - 1];1068 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);1069 Register SrcReg = FinalCopy->getOperand(1).getReg();1070 1071 GISelValueTracking Info(*MF);1072 1073 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);1074 1075 EXPECT_EQ(fcPosFinite, Known.KnownFPClasses);1076 EXPECT_EQ(false, Known.SignBit);1077}1078 1079TEST_F(AArch64GISelMITest, TestFPClassConcatVec) {1080 StringRef MIRString = R"(1081 %ptr:_(p0) = G_IMPLICIT_DEF1082 %vec1:_(<2 x s32>) = G_LOAD %ptr(p0) :: (load (<2 x s32>))1083 %c1:_(s32) = G_FCONSTANT float 1.01084 %c2:_(s32) = G_FCONSTANT float 2.01085 %vec2:_(<2 x s32>) = G_BUILD_VECTOR %c1, %c21086 %fabs1:_(<2 x s32>) = nnan ninf G_FABS %vec11087 %fabs2:_(<2 x s32>) = nnan ninf G_FABS %vec21088 %cat:_(<4 x s32>) = G_CONCAT_VECTORS %fabs1, %fabs21089 %copy_cat:_(<4 x s32>) = COPY %cat1090)";1091 1092 setUp(MIRString);1093 if (!TM)1094 GTEST_SKIP();1095 1096 Register CopyReg = Copies[Copies.size() - 1];1097 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);1098 Register SrcReg = FinalCopy->getOperand(1).getReg();1099 1100 GISelValueTracking Info(*MF);1101 1102 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);1103 1104 EXPECT_EQ(fcPosFinite, Known.KnownFPClasses);1105 EXPECT_EQ(false, Known.SignBit);1106}1107 1108TEST_F(AArch64GISelMITest, TestFPClassVecExtractElem) {1109 StringRef MIRString = R"(1110 %ptr:_(p0) = G_IMPLICIT_DEF1111 %vec:_(<4 x s32>) = G_LOAD %ptr(p0) :: (load (<4 x s32>))1112 %fabs:_(<4 x s32>) = nnan ninf G_FABS %vec1113 %idx:_(s64) = G_CONSTANT i64 11114 %extract:_(s32) = G_EXTRACT_VECTOR_ELT %fabs, %idx1115 %copy_elem:_(s32) = COPY %extract1116)";1117 1118 setUp(MIRString);1119 if (!TM)1120 GTEST_SKIP();1121 1122 Register CopyReg = Copies[Copies.size() - 1];1123 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);1124 Register SrcReg = FinalCopy->getOperand(1).getReg();1125 1126 GISelValueTracking Info(*MF);1127 1128 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);1129 1130 EXPECT_EQ(fcPosFinite, Known.KnownFPClasses);1131 EXPECT_EQ(false, Known.SignBit);1132}1133 1134TEST_F(AArch64GISelMITest, TestFPClassVecInsertElem) {1135 StringRef MIRString = R"(1136 %ptr:_(p0) = G_IMPLICIT_DEF1137 %vec:_(<4 x s32>) = G_LOAD %ptr(p0) :: (load (<4 x s32>))1138 %fabs1:_(<4 x s32>) = nnan ninf G_FABS %vec1139 %elem:_(s32) = G_LOAD %ptr(p0) :: (load (s32))1140 %fabs2:_(s32) = nnan ninf G_FABS %elem1141 %idx:_(s64) = G_CONSTANT i64 11142 %insert:_(<4 x s32>) = G_INSERT_VECTOR_ELT %fabs1, %fabs2, %idx1143 %copy_insert:_(<4 x s32>) = COPY %insert1144)";1145 1146 setUp(MIRString);1147 if (!TM)1148 GTEST_SKIP();1149 1150 Register CopyReg = Copies[Copies.size() - 1];1151 MachineInstr *FinalCopy = MRI->getVRegDef(CopyReg);1152 Register SrcReg = FinalCopy->getOperand(1).getReg();1153 1154 GISelValueTracking Info(*MF);1155 1156 KnownFPClass Known = Info.computeKnownFPClass(SrcReg);1157 1158 EXPECT_EQ(fcPosFinite, Known.KnownFPClasses);1159 EXPECT_EQ(false, Known.SignBit);1160}1161