507 lines · cpp
1//===- GISelUtilsTest.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/CodeGen/GlobalISel/Utils.h"11#include "gtest/gtest.h"12 13using namespace llvm;14 15namespace {16static const LLT S1 = LLT::scalar(1);17static const LLT S8 = LLT::scalar(8);18static const LLT S16 = LLT::scalar(16);19static const LLT S32 = LLT::scalar(32);20static const LLT S64 = LLT::scalar(64);21static const LLT P0 = LLT::pointer(0, 64);22static const LLT P1 = LLT::pointer(1, 32);23 24static const LLT V2S8 = LLT::fixed_vector(2, 8);25static const LLT V4S8 = LLT::fixed_vector(4, 8);26static const LLT V8S8 = LLT::fixed_vector(8, 8);27 28static const LLT V2S16 = LLT::fixed_vector(2, 16);29static const LLT V3S16 = LLT::fixed_vector(3, 16);30static const LLT V4S16 = LLT::fixed_vector(4, 16);31 32static const LLT V2S32 = LLT::fixed_vector(2, 32);33static const LLT V3S32 = LLT::fixed_vector(3, 32);34static const LLT V4S32 = LLT::fixed_vector(4, 32);35static const LLT V6S32 = LLT::fixed_vector(6, 32);36 37static const LLT V2S64 = LLT::fixed_vector(2, 64);38static const LLT V3S64 = LLT::fixed_vector(3, 64);39static const LLT V4S64 = LLT::fixed_vector(4, 64);40 41static const LLT V2P0 = LLT::fixed_vector(2, P0);42static const LLT V3P0 = LLT::fixed_vector(3, P0);43static const LLT V4P0 = LLT::fixed_vector(4, P0);44static const LLT V6P0 = LLT::fixed_vector(6, P0);45 46static const LLT V2P1 = LLT::fixed_vector(2, P1);47static const LLT V4P1 = LLT::fixed_vector(4, P1);48 49static const LLT NXV1S1 = LLT::scalable_vector(1, S1);50static const LLT NXV2S1 = LLT::scalable_vector(2, S1);51static const LLT NXV3S1 = LLT::scalable_vector(3, S1);52static const LLT NXV4S1 = LLT::scalable_vector(4, S1);53static const LLT NXV12S1 = LLT::scalable_vector(12, S1);54static const LLT NXV32S1 = LLT::scalable_vector(32, S1);55static const LLT NXV64S1 = LLT::scalable_vector(64, S1);56static const LLT NXV128S1 = LLT::scalable_vector(128, S1);57static const LLT NXV384S1 = LLT::scalable_vector(384, S1);58 59static const LLT NXV1S32 = LLT::scalable_vector(1, S32);60static const LLT NXV2S32 = LLT::scalable_vector(2, S32);61static const LLT NXV3S32 = LLT::scalable_vector(3, S32);62static const LLT NXV4S32 = LLT::scalable_vector(4, S32);63static const LLT NXV8S32 = LLT::scalable_vector(8, S32);64static const LLT NXV12S32 = LLT::scalable_vector(12, S32);65static const LLT NXV24S32 = LLT::scalable_vector(24, S32);66 67static const LLT NXV1S64 = LLT::scalable_vector(1, S64);68static const LLT NXV2S64 = LLT::scalable_vector(2, S64);69static const LLT NXV3S64 = LLT::scalable_vector(3, S64);70static const LLT NXV4S64 = LLT::scalable_vector(4, S64);71static const LLT NXV6S64 = LLT::scalable_vector(6, S64);72static const LLT NXV12S64 = LLT::scalable_vector(12, S64);73 74static const LLT NXV1P0 = LLT::scalable_vector(1, P0);75static const LLT NXV2P0 = LLT::scalable_vector(2, P0);76static const LLT NXV3P0 = LLT::scalable_vector(3, P0);77static const LLT NXV4P0 = LLT::scalable_vector(4, P0);78static const LLT NXV12P0 = LLT::scalable_vector(12, P0);79 80static void collectNonCopyMI(SmallVectorImpl<MachineInstr *> &MIList,81 MachineFunction *MF) {82 for (auto &MBB : *MF)83 for (MachineInstr &MI : MBB) {84 if (MI.getOpcode() != TargetOpcode::COPY)85 MIList.push_back(&MI);86 }87}88 89TEST(GISelUtilsTest, getGCDType) {90 EXPECT_EQ(S1, getGCDType(S1, S1));91 EXPECT_EQ(S32, getGCDType(S32, S32));92 EXPECT_EQ(S1, getGCDType(S1, S32));93 EXPECT_EQ(S1, getGCDType(S32, S1));94 EXPECT_EQ(S16, getGCDType(S16, S32));95 EXPECT_EQ(S16, getGCDType(S32, S16));96 97 EXPECT_EQ(V2S32, getGCDType(V2S32, V2S32));98 EXPECT_EQ(S32, getGCDType(V3S32, V2S32));99 EXPECT_EQ(S32, getGCDType(V2S32, V3S32));100 101 EXPECT_EQ(V2S16, getGCDType(V4S16, V2S16));102 EXPECT_EQ(V2S16, getGCDType(V2S16, V4S16));103 104 EXPECT_EQ(V2S32, getGCDType(V4S32, V2S32));105 EXPECT_EQ(V2S32, getGCDType(V2S32, V4S32));106 107 EXPECT_EQ(S16, getGCDType(P0, S16));108 EXPECT_EQ(S16, getGCDType(S16, P0));109 110 EXPECT_EQ(S32, getGCDType(P0, S32));111 EXPECT_EQ(S32, getGCDType(S32, P0));112 113 EXPECT_EQ(P0, getGCDType(P0, S64));114 EXPECT_EQ(S64, getGCDType(S64, P0));115 116 EXPECT_EQ(S32, getGCDType(P0, P1));117 EXPECT_EQ(S32, getGCDType(P1, P0));118 119 EXPECT_EQ(P0, getGCDType(V3P0, V2P0));120 EXPECT_EQ(P0, getGCDType(V2P0, V3P0));121 122 EXPECT_EQ(P0, getGCDType(P0, V2P0));123 EXPECT_EQ(P0, getGCDType(V2P0, P0));124 125 126 EXPECT_EQ(V2P0, getGCDType(V2P0, V2P0));127 EXPECT_EQ(P0, getGCDType(V3P0, V2P0));128 EXPECT_EQ(P0, getGCDType(V2P0, V3P0));129 EXPECT_EQ(V2P0, getGCDType(V4P0, V2P0));130 131 EXPECT_EQ(V2P0, getGCDType(V2P0, V4P1));132 EXPECT_EQ(V4P1, getGCDType(V4P1, V2P0));133 134 EXPECT_EQ(V2P0, getGCDType(V4P0, V4P1));135 EXPECT_EQ(V4P1, getGCDType(V4P1, V4P0));136 137 // Elements have same size, but have different pointeriness, so prefer the138 // original element type.139 EXPECT_EQ(V2P0, getGCDType(V2P0, V4S64));140 EXPECT_EQ(V2S64, getGCDType(V4S64, V2P0));141 142 EXPECT_EQ(V2S16, getGCDType(V2S16, V4P1));143 EXPECT_EQ(P1, getGCDType(V4P1, V2S16));144 EXPECT_EQ(V2P1, getGCDType(V4P1, V4S16));145 EXPECT_EQ(V4S16, getGCDType(V4S16, V2P1));146 147 EXPECT_EQ(P0, getGCDType(P0, V2S64));148 EXPECT_EQ(S64, getGCDType(V2S64, P0));149 150 EXPECT_EQ(S16, getGCDType(V2S16, V3S16));151 EXPECT_EQ(S16, getGCDType(V3S16, V2S16));152 EXPECT_EQ(S16, getGCDType(V3S16, S16));153 EXPECT_EQ(S16, getGCDType(S16, V3S16));154 155 EXPECT_EQ(V2S16, getGCDType(V2S16, V2S32));156 EXPECT_EQ(S32, getGCDType(V2S32, V2S16));157 158 EXPECT_EQ(V4S8, getGCDType(V4S8, V2S32));159 EXPECT_EQ(S32, getGCDType(V2S32, V4S8));160 161 // Test cases where neither element type nicely divides.162 EXPECT_EQ(LLT::scalar(3),163 getGCDType(LLT::fixed_vector(3, 5), LLT::fixed_vector(2, 6)));164 EXPECT_EQ(LLT::scalar(3),165 getGCDType(LLT::fixed_vector(2, 6), LLT::fixed_vector(3, 5)));166 167 // Have to go smaller than a pointer element.168 EXPECT_EQ(LLT::scalar(3), getGCDType(LLT::fixed_vector(2, LLT::pointer(3, 6)),169 LLT::fixed_vector(3, 5)));170 EXPECT_EQ(LLT::scalar(3),171 getGCDType(LLT::fixed_vector(3, 5),172 LLT::fixed_vector(2, LLT::pointer(3, 6))));173 174 EXPECT_EQ(V4S8, getGCDType(V4S8, S32));175 EXPECT_EQ(S32, getGCDType(S32, V4S8));176 EXPECT_EQ(V4S8, getGCDType(V4S8, P1));177 EXPECT_EQ(P1, getGCDType(P1, V4S8));178 179 EXPECT_EQ(V2S8, getGCDType(V2S8, V4S16));180 EXPECT_EQ(S16, getGCDType(V4S16, V2S8));181 182 EXPECT_EQ(S8, getGCDType(V2S8, LLT::fixed_vector(4, 2)));183 EXPECT_EQ(LLT::fixed_vector(4, 2), getGCDType(LLT::fixed_vector(4, 2), S8));184 185 EXPECT_EQ(LLT::pointer(4, 8),186 getGCDType(LLT::fixed_vector(2, LLT::pointer(4, 8)),187 LLT::fixed_vector(4, 2)));188 189 EXPECT_EQ(LLT::fixed_vector(4, 2),190 getGCDType(LLT::fixed_vector(4, 2),191 LLT::fixed_vector(2, LLT::pointer(4, 8))));192 193 EXPECT_EQ(LLT::scalar(4), getGCDType(LLT::fixed_vector(3, 4), S8));194 EXPECT_EQ(LLT::scalar(4), getGCDType(S8, LLT::fixed_vector(3, 4)));195 196 // Scalable -> Scalable197 EXPECT_EQ(NXV1S1, getGCDType(NXV1S1, NXV1S32));198 EXPECT_EQ(NXV1S32, getGCDType(NXV1S64, NXV1S32));199 EXPECT_EQ(NXV1S32, getGCDType(NXV1S32, NXV1S64));200 EXPECT_EQ(NXV1P0, getGCDType(NXV1P0, NXV1S64));201 EXPECT_EQ(NXV1S64, getGCDType(NXV1S64, NXV1P0));202 203 EXPECT_EQ(NXV4S1, getGCDType(NXV4S1, NXV4S32));204 EXPECT_EQ(NXV2S64, getGCDType(NXV4S64, NXV4S32));205 EXPECT_EQ(NXV4S32, getGCDType(NXV4S32, NXV4S64));206 EXPECT_EQ(NXV4P0, getGCDType(NXV4P0, NXV4S64));207 EXPECT_EQ(NXV4S64, getGCDType(NXV4S64, NXV4P0));208 209 EXPECT_EQ(NXV4S1, getGCDType(NXV4S1, NXV2S32));210 EXPECT_EQ(NXV1S64, getGCDType(NXV4S64, NXV2S32));211 EXPECT_EQ(NXV4S32, getGCDType(NXV4S32, NXV2S64));212 EXPECT_EQ(NXV2P0, getGCDType(NXV4P0, NXV2S64));213 EXPECT_EQ(NXV2S64, getGCDType(NXV4S64, NXV2P0));214 215 EXPECT_EQ(NXV2S1, getGCDType(NXV2S1, NXV4S32));216 EXPECT_EQ(NXV2S64, getGCDType(NXV2S64, NXV4S32));217 EXPECT_EQ(NXV2S32, getGCDType(NXV2S32, NXV4S64));218 EXPECT_EQ(NXV2P0, getGCDType(NXV2P0, NXV4S64));219 EXPECT_EQ(NXV2S64, getGCDType(NXV2S64, NXV4P0));220 221 EXPECT_EQ(NXV1S1, getGCDType(NXV3S1, NXV4S32));222 EXPECT_EQ(NXV1S64, getGCDType(NXV3S64, NXV4S32));223 EXPECT_EQ(NXV1S32, getGCDType(NXV3S32, NXV4S64));224 EXPECT_EQ(NXV1P0, getGCDType(NXV3P0, NXV4S64));225 EXPECT_EQ(NXV1S64, getGCDType(NXV3S64, NXV4P0));226 227 EXPECT_EQ(NXV1S1, getGCDType(NXV3S1, NXV4S1));228 EXPECT_EQ(NXV1S32, getGCDType(NXV3S32, NXV4S32));229 EXPECT_EQ(NXV1S64, getGCDType(NXV3S64, NXV4S64));230 EXPECT_EQ(NXV1P0, getGCDType(NXV3P0, NXV4P0));231 232 // Scalable, Scalar233 234 EXPECT_EQ(S1, getGCDType(NXV1S1, S1));235 EXPECT_EQ(S1, getGCDType(NXV1S1, S32));236 EXPECT_EQ(S1, getGCDType(NXV1S32, S1));237 EXPECT_EQ(S32, getGCDType(NXV1S32, S32));238 EXPECT_EQ(S32, getGCDType(NXV1S32, S64));239 EXPECT_EQ(S1, getGCDType(NXV2S32, S1));240 EXPECT_EQ(S32, getGCDType(NXV2S32, S32));241 EXPECT_EQ(S32, getGCDType(NXV2S32, S64));242 243 EXPECT_EQ(S1, getGCDType(S1, NXV1S1));244 EXPECT_EQ(S1, getGCDType(S32, NXV1S1));245 EXPECT_EQ(S1, getGCDType(S1, NXV1S32));246 EXPECT_EQ(S32, getGCDType(S32, NXV1S32));247 EXPECT_EQ(S32, getGCDType(S64, NXV1S32));248 EXPECT_EQ(S1, getGCDType(S1, NXV2S32));249 EXPECT_EQ(S32, getGCDType(S32, NXV2S32));250 EXPECT_EQ(S32, getGCDType(S64, NXV2S32));251}252 253TEST(GISelUtilsTest, getLCMType) {254 EXPECT_EQ(S1, getLCMType(S1, S1));255 EXPECT_EQ(S32, getLCMType(S32, S1));256 EXPECT_EQ(S32, getLCMType(S1, S32));257 EXPECT_EQ(S32, getLCMType(S32, S32));258 259 EXPECT_EQ(S32, getLCMType(S32, S16));260 EXPECT_EQ(S32, getLCMType(S16, S32));261 262 EXPECT_EQ(S64, getLCMType(S64, P0));263 EXPECT_EQ(P0, getLCMType(P0, S64));264 265 EXPECT_EQ(P0, getLCMType(S32, P0));266 EXPECT_EQ(P0, getLCMType(P0, S32));267 268 EXPECT_EQ(S32, getLCMType(S32, P1));269 EXPECT_EQ(P1, getLCMType(P1, S32));270 EXPECT_EQ(P0, getLCMType(P0, P0));271 EXPECT_EQ(P1, getLCMType(P1, P1));272 273 EXPECT_EQ(P0, getLCMType(P0, P1));274 EXPECT_EQ(P0, getLCMType(P1, P0));275 276 EXPECT_EQ(V2S32, getLCMType(V2S32, V2S32));277 EXPECT_EQ(V2S32, getLCMType(V2S32, S32));278 EXPECT_EQ(V2S32, getLCMType(S32, V2S32));279 EXPECT_EQ(V2S32, getLCMType(V2S32, V2S32));280 EXPECT_EQ(V6S32, getLCMType(V2S32, V3S32));281 EXPECT_EQ(V6S32, getLCMType(V3S32, V2S32));282 EXPECT_EQ(LLT::fixed_vector(12, S32), getLCMType(V4S32, V3S32));283 EXPECT_EQ(LLT::fixed_vector(12, S32), getLCMType(V3S32, V4S32));284 285 EXPECT_EQ(V2P0, getLCMType(V2P0, V2P0));286 EXPECT_EQ(V2P0, getLCMType(V2P0, P0));287 EXPECT_EQ(V2P0, getLCMType(P0, V2P0));288 EXPECT_EQ(V2P0, getLCMType(V2P0, V2P0));289 EXPECT_EQ(V6P0, getLCMType(V2P0, V3P0));290 EXPECT_EQ(V6P0, getLCMType(V3P0, V2P0));291 EXPECT_EQ(LLT::fixed_vector(12, P0), getLCMType(V4P0, V3P0));292 EXPECT_EQ(LLT::fixed_vector(12, P0), getLCMType(V3P0, V4P0));293 294 EXPECT_EQ(LLT::fixed_vector(12, S64), getLCMType(V4S64, V3P0));295 EXPECT_EQ(LLT::fixed_vector(12, P0), getLCMType(V3P0, V4S64));296 297 EXPECT_EQ(LLT::fixed_vector(12, P0), getLCMType(V4P0, V3S64));298 EXPECT_EQ(LLT::fixed_vector(12, S64), getLCMType(V3S64, V4P0));299 300 EXPECT_EQ(V2P0, getLCMType(V2P0, S32));301 EXPECT_EQ(V4S32, getLCMType(S32, V2P0));302 EXPECT_EQ(V2P0, getLCMType(V2P0, S64));303 EXPECT_EQ(V2S64, getLCMType(S64, V2P0));304 305 306 EXPECT_EQ(V2P0, getLCMType(V2P0, V2P1));307 EXPECT_EQ(V4P1, getLCMType(V2P1, V2P0));308 309 EXPECT_EQ(V2P0, getLCMType(V2P0, V4P1));310 EXPECT_EQ(V4P1, getLCMType(V4P1, V2P0));311 312 313 EXPECT_EQ(V2S32, getLCMType(V2S32, S64));314 EXPECT_EQ(S64, getLCMType(S64, V2S32));315 316 EXPECT_EQ(V4S16, getLCMType(V4S16, V2S32));317 EXPECT_EQ(V2S32, getLCMType(V2S32, V4S16));318 319 EXPECT_EQ(V2S32, getLCMType(V2S32, V4S8));320 EXPECT_EQ(V8S8, getLCMType(V4S8, V2S32));321 322 EXPECT_EQ(V2S16, getLCMType(V2S16, V4S8));323 EXPECT_EQ(V4S8, getLCMType(V4S8, V2S16));324 325 EXPECT_EQ(LLT::fixed_vector(6, S16), getLCMType(V3S16, V4S8));326 EXPECT_EQ(LLT::fixed_vector(12, S8), getLCMType(V4S8, V3S16));327 EXPECT_EQ(V4S16, getLCMType(V4S16, V4S8));328 EXPECT_EQ(V8S8, getLCMType(V4S8, V4S16));329 330 EXPECT_EQ(LLT::fixed_vector(6, 4), getLCMType(LLT::fixed_vector(3, 4), S8));331 EXPECT_EQ(LLT::fixed_vector(3, 8), getLCMType(S8, LLT::fixed_vector(3, 4)));332 333 EXPECT_EQ(LLT::fixed_vector(6, 4),334 getLCMType(LLT::fixed_vector(3, 4), LLT::pointer(4, 8)));335 EXPECT_EQ(LLT::fixed_vector(3, LLT::pointer(4, 8)),336 getLCMType(LLT::pointer(4, 8), LLT::fixed_vector(3, 4)));337 338 EXPECT_EQ(V2S64, getLCMType(V2S64, P0));339 EXPECT_EQ(V2P0, getLCMType(P0, V2S64));340 341 EXPECT_EQ(V2S64, getLCMType(V2S64, P1));342 EXPECT_EQ(V4P1, getLCMType(P1, V2S64));343 344 // Scalable, Scalable345 EXPECT_EQ(NXV32S1, getLCMType(NXV1S1, NXV1S32));346 EXPECT_EQ(NXV1S64, getLCMType(NXV1S64, NXV1S32));347 EXPECT_EQ(NXV2S32, getLCMType(NXV1S32, NXV1S64));348 EXPECT_EQ(NXV1P0, getLCMType(NXV1P0, NXV1S64));349 EXPECT_EQ(NXV1S64, getLCMType(NXV1S64, NXV1P0));350 351 EXPECT_EQ(NXV128S1, getLCMType(NXV4S1, NXV4S32));352 EXPECT_EQ(NXV4S64, getLCMType(NXV4S64, NXV4S32));353 EXPECT_EQ(NXV8S32, getLCMType(NXV4S32, NXV4S64));354 EXPECT_EQ(NXV4P0, getLCMType(NXV4P0, NXV4S64));355 EXPECT_EQ(NXV4S64, getLCMType(NXV4S64, NXV4P0));356 357 EXPECT_EQ(NXV64S1, getLCMType(NXV4S1, NXV2S32));358 EXPECT_EQ(NXV4S64, getLCMType(NXV4S64, NXV2S32));359 EXPECT_EQ(NXV4S32, getLCMType(NXV4S32, NXV2S64));360 EXPECT_EQ(NXV4P0, getLCMType(NXV4P0, NXV2S64));361 EXPECT_EQ(NXV4S64, getLCMType(NXV4S64, NXV2P0));362 363 EXPECT_EQ(NXV128S1, getLCMType(NXV2S1, NXV4S32));364 EXPECT_EQ(NXV2S64, getLCMType(NXV2S64, NXV4S32));365 EXPECT_EQ(NXV8S32, getLCMType(NXV2S32, NXV4S64));366 EXPECT_EQ(NXV4P0, getLCMType(NXV2P0, NXV4S64));367 EXPECT_EQ(NXV4S64, getLCMType(NXV2S64, NXV4P0));368 369 EXPECT_EQ(NXV384S1, getLCMType(NXV3S1, NXV4S32));370 EXPECT_EQ(NXV6S64, getLCMType(NXV3S64, NXV4S32));371 EXPECT_EQ(NXV24S32, getLCMType(NXV3S32, NXV4S64));372 EXPECT_EQ(NXV12P0, getLCMType(NXV3P0, NXV4S64));373 EXPECT_EQ(NXV12S64, getLCMType(NXV3S64, NXV4P0));374 375 EXPECT_EQ(NXV12S1, getLCMType(NXV3S1, NXV4S1));376 EXPECT_EQ(NXV12S32, getLCMType(NXV3S32, NXV4S32));377 EXPECT_EQ(NXV12S64, getLCMType(NXV3S64, NXV4S64));378 EXPECT_EQ(NXV12P0, getLCMType(NXV3P0, NXV4P0));379 380 // Scalable, Scalar381 382 EXPECT_EQ(NXV1S1, getLCMType(NXV1S1, S1));383 EXPECT_EQ(NXV32S1, getLCMType(NXV1S1, S32));384 EXPECT_EQ(NXV1S32, getLCMType(NXV1S32, S1));385 EXPECT_EQ(NXV1S32, getLCMType(NXV1S32, S32));386 EXPECT_EQ(NXV2S32, getLCMType(NXV1S32, S64));387 EXPECT_EQ(NXV2S32, getLCMType(NXV2S32, S1));388 EXPECT_EQ(NXV2S32, getLCMType(NXV2S32, S32));389 EXPECT_EQ(NXV2S32, getLCMType(NXV2S32, S64));390 391 EXPECT_EQ(NXV1S1, getLCMType(S1, NXV1S1));392 EXPECT_EQ(NXV1S32, getLCMType(S32, NXV1S1));393 EXPECT_EQ(NXV32S1, getLCMType(S1, NXV1S32));394 EXPECT_EQ(NXV1S32, getLCMType(S32, NXV1S32));395 EXPECT_EQ(NXV1S64, getLCMType(S64, NXV1S32));396 EXPECT_EQ(NXV64S1, getLCMType(S1, NXV2S32));397 EXPECT_EQ(NXV2S32, getLCMType(S32, NXV2S32));398 EXPECT_EQ(NXV1S64, getLCMType(S64, NXV2S32));399}400 401TEST_F(AArch64GISelMITest, ConstFalseTest) {402 setUp();403 if (!TM)404 GTEST_SKIP();405 const auto &TLI = *B.getMF().getSubtarget().getTargetLowering();406 bool BooleanChoices[2] = {true, false};407 408 // AArch64 uses ZeroOrOneBooleanContent for scalars, and409 // ZeroOrNegativeOneBooleanContent for vectors.410 for (auto IsVec : BooleanChoices) {411 for (auto IsFP : BooleanChoices) {412 EXPECT_TRUE(isConstFalseVal(TLI, 0, IsVec, IsFP));413 EXPECT_FALSE(isConstFalseVal(TLI, 1, IsVec, IsFP));414 415 // This would be true with UndefinedBooleanContent.416 EXPECT_FALSE(isConstFalseVal(TLI, 2, IsVec, IsFP));417 }418 }419}420 421TEST_F(AMDGPUGISelMITest, isConstantOrConstantSplatVectorFP) {422 StringRef MIRString =423 " %cst0:_(s32) = G_FCONSTANT float 2.000000e+00\n"424 " %cst1:_(s32) = G_FCONSTANT float 0.0\n"425 " %cst2:_(s64) = G_FCONSTANT double 3.000000e-02\n"426 " %cst3:_(s32) = G_CONSTANT i32 2\n"427 " %cst4:_(<2 x s32>) = G_BUILD_VECTOR %cst0(s32), %cst0(s32)\n"428 " %cst5:_(<2 x s32>) = G_BUILD_VECTOR %cst1(s32), %cst0(s32)\n"429 " %cst6:_(<2 x s64>) = G_BUILD_VECTOR %cst2(s64), %cst2(s64)\n"430 " %cst7:_(<2 x s32>) = G_BUILD_VECTOR %cst3(s32), %cst3:_(s32)\n"431 " %cst8:_(<4 x s32>) = G_CONCAT_VECTORS %cst4:_(<2 x s32>), %cst4:_(<2 "432 "x s32>)\n"433 " %cst9:_(<4 x s64>) = G_CONCAT_VECTORS %cst6:_(<2 x s64>), %cst6:_(<2 "434 "x s64>)\n"435 " %cst10:_(<4 x s32>) = G_CONCAT_VECTORS %cst4:_(<2 x s32>), %cst5:_(<2 "436 "x s32>)\n"437 " %cst11:_(<4 x s32>) = G_CONCAT_VECTORS %cst7:_(<2 x s32>), %cst7:_(<2 "438 "x s32>)\n"439 " %cst12:_(s32) = G_IMPLICIT_DEF \n"440 " %cst13:_(<2 x s32>) = G_BUILD_VECTOR %cst12(s32), %cst12(s32)\n"441 " %cst14:_(<2 x s32>) = G_BUILD_VECTOR %cst0(s32), %cst12(s32)\n"442 " %cst15:_(<4 x s32>) = G_CONCAT_VECTORS %cst4:_(<2 x s32>), "443 "%cst14:_(<2 "444 "x s32>)\n";445 446 SmallVector<MachineInstr *, 16> MIList;447 448 setUp(MIRString);449 if (!TM)450 GTEST_SKIP();451 452 collectNonCopyMI(MIList, MF);453 454 EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[0], *MRI).has_value());455 auto val = isConstantOrConstantSplatVectorFP(*MIList[0], *MRI).value();456 EXPECT_EQ(2.0, val.convertToFloat());457 458 EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[1], *MRI).has_value());459 val = isConstantOrConstantSplatVectorFP(*MIList[1], *MRI).value();460 EXPECT_EQ(0.0, val.convertToFloat());461 462 EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[2], *MRI).has_value());463 val = isConstantOrConstantSplatVectorFP(*MIList[2], *MRI).value();464 EXPECT_EQ(0.03, val.convertToDouble());465 466 EXPECT_FALSE(isConstantOrConstantSplatVectorFP(*MIList[3], *MRI).has_value());467 468 EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[4], *MRI).has_value());469 val = isConstantOrConstantSplatVectorFP(*MIList[4], *MRI).value();470 EXPECT_EQ(2.0, val.convertToFloat());471 472 EXPECT_FALSE(isConstantOrConstantSplatVectorFP(*MIList[5], *MRI).has_value());473 474 EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[6], *MRI).has_value());475 val = isConstantOrConstantSplatVectorFP(*MIList[6], *MRI).value();476 EXPECT_EQ(0.03, val.convertToDouble());477 478 EXPECT_FALSE(isConstantOrConstantSplatVectorFP(*MIList[7], *MRI).has_value());479 480 EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[8], *MRI).has_value());481 val = isConstantOrConstantSplatVectorFP(*MIList[8], *MRI).value();482 EXPECT_EQ(2.0, val.convertToFloat());483 484 EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[9], *MRI).has_value());485 val = isConstantOrConstantSplatVectorFP(*MIList[9], *MRI).value();486 EXPECT_EQ(0.03, val.convertToDouble());487 488 EXPECT_FALSE(489 isConstantOrConstantSplatVectorFP(*MIList[10], *MRI).has_value());490 491 EXPECT_FALSE(492 isConstantOrConstantSplatVectorFP(*MIList[11], *MRI).has_value());493 494 EXPECT_FALSE(495 isConstantOrConstantSplatVectorFP(*MIList[12], *MRI).has_value());496 497 EXPECT_FALSE(498 isConstantOrConstantSplatVectorFP(*MIList[13], *MRI).has_value());499 500 EXPECT_FALSE(501 isConstantOrConstantSplatVectorFP(*MIList[14], *MRI).has_value());502 503 EXPECT_FALSE(504 isConstantOrConstantSplatVectorFP(*MIList[15], *MRI).has_value());505}506}507