537 lines · cpp
1//===- llvm/unittest/CodeGen/GlobalISel/LegalizerInfoTest.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 "llvm/CodeGen/GlobalISel/LegalizerInfo.h"10#include "llvm/CodeGen/TargetOpcodes.h"11#include "GISelMITest.h"12#include "gtest/gtest.h"13 14using namespace llvm;15using namespace LegalizeActions;16using namespace LegalityPredicates;17using namespace LegalizeMutations;18 19// Define a couple of pretty printers to help debugging when things go wrong.20namespace llvm {21std::ostream &22operator<<(std::ostream &OS, const LegalizeAction Act) {23 switch (Act) {24 case Lower: OS << "Lower"; break;25 case Legal: OS << "Legal"; break;26 case NarrowScalar: OS << "NarrowScalar"; break;27 case WidenScalar: OS << "WidenScalar"; break;28 case FewerElements: OS << "FewerElements"; break;29 case MoreElements: OS << "MoreElements"; break;30 case Libcall: OS << "Libcall"; break;31 case Custom: OS << "Custom"; break;32 case Bitcast: OS << "Bitcast"; break;33 case Unsupported: OS << "Unsupported"; break;34 case NotFound: OS << "NotFound"; break;35 case UseLegacyRules: OS << "UseLegacyRules"; break;36 }37 return OS;38}39 40std::ostream &operator<<(std::ostream &OS, const llvm::LegalizeActionStep Ty) {41 OS << "LegalizeActionStep(" << Ty.Action << ", " << Ty.TypeIdx << ", "42 << Ty.NewType << ')';43 return OS;44}45}46 47namespace {48 49 50TEST(LegalizerInfoTest, ScalarRISC) {51 using namespace TargetOpcode;52 LegalizerInfo L;53 auto &LegacyInfo = L.getLegacyLegalizerInfo();54 // Typical RISCy set of operations based on AArch64.55 for (unsigned Op : {G_ADD, G_SUB}) {56 for (unsigned Size : {32, 64})57 LegacyInfo.setAction({Op, 0, LLT::scalar(Size)},58 LegacyLegalizeActions::Legal);59 LegacyInfo.setLegalizeScalarToDifferentSizeStrategy(60 Op, 0, LegacyLegalizerInfo::widenToLargerTypesAndNarrowToLargest);61 }62 63 LegacyInfo.computeTables();64 65 for (unsigned opcode : {G_ADD, G_SUB}) {66 // Check we infer the correct types and actually do what we're told.67 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(8)}}),68 LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));69 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(16)}}),70 LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));71 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(32)}}),72 LegalizeActionStep(Legal, 0, LLT{}));73 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(64)}}),74 LegalizeActionStep(Legal, 0, LLT{}));75 76 // Make sure the default for over-sized types applies.77 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(128)}}),78 LegalizeActionStep(NarrowScalar, 0, LLT::scalar(64)));79 // Make sure we also handle unusual sizes80 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(1)}}),81 LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));82 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(31)}}),83 LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));84 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(33)}}),85 LegalizeActionStep(WidenScalar, 0, LLT::scalar(64)));86 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(63)}}),87 LegalizeActionStep(WidenScalar, 0, LLT::scalar(64)));88 EXPECT_EQ(L.getAction({opcode, {LLT::scalar(65)}}),89 LegalizeActionStep(NarrowScalar, 0, LLT::scalar(64)));90 }91}92 93TEST(LegalizerInfoTest, VectorRISC) {94 using namespace TargetOpcode;95 LegalizerInfo L;96 auto &LegacyInfo = L.getLegacyLegalizerInfo();97 // Typical RISCy set of operations based on ARM.98 LegacyInfo.setAction({G_ADD, LLT::fixed_vector(8, 8)},99 LegacyLegalizeActions::Legal);100 LegacyInfo.setAction({G_ADD, LLT::fixed_vector(16, 8)},101 LegacyLegalizeActions::Legal);102 LegacyInfo.setAction({G_ADD, LLT::fixed_vector(4, 16)},103 LegacyLegalizeActions::Legal);104 LegacyInfo.setAction({G_ADD, LLT::fixed_vector(8, 16)},105 LegacyLegalizeActions::Legal);106 LegacyInfo.setAction({G_ADD, LLT::fixed_vector(2, 32)},107 LegacyLegalizeActions::Legal);108 LegacyInfo.setAction({G_ADD, LLT::fixed_vector(4, 32)},109 LegacyLegalizeActions::Legal);110 111 LegacyInfo.setLegalizeVectorElementToDifferentSizeStrategy(112 G_ADD, 0, LegacyLegalizerInfo::widenToLargerTypesUnsupportedOtherwise);113 114 LegacyInfo.setAction({G_ADD, 0, LLT::scalar(32)},115 LegacyLegalizeActions::Legal);116 117 LegacyInfo.computeTables();118 119 // Check we infer the correct types and actually do what we're told for some120 // simple cases.121 EXPECT_EQ(L.getAction({G_ADD, {LLT::fixed_vector(8, 8)}}),122 LegalizeActionStep(Legal, 0, LLT{}));123 EXPECT_EQ(L.getAction({G_ADD, {LLT::fixed_vector(8, 7)}}),124 LegalizeActionStep(WidenScalar, 0, LLT::fixed_vector(8, 8)));125 EXPECT_EQ(L.getAction({G_ADD, {LLT::fixed_vector(2, 8)}}),126 LegalizeActionStep(MoreElements, 0, LLT::fixed_vector(8, 8)));127 EXPECT_EQ(L.getAction({G_ADD, {LLT::fixed_vector(8, 32)}}),128 LegalizeActionStep(FewerElements, 0, LLT::fixed_vector(4, 32)));129 // Check a few non-power-of-2 sizes:130 EXPECT_EQ(L.getAction({G_ADD, {LLT::fixed_vector(3, 3)}}),131 LegalizeActionStep(WidenScalar, 0, LLT::fixed_vector(3, 8)));132 EXPECT_EQ(L.getAction({G_ADD, {LLT::fixed_vector(3, 8)}}),133 LegalizeActionStep(MoreElements, 0, LLT::fixed_vector(8, 8)));134}135 136TEST(LegalizerInfoTest, MultipleTypes) {137 using namespace TargetOpcode;138 LegalizerInfo L;139 auto &LegacyInfo = L.getLegacyLegalizerInfo();140 LLT p0 = LLT::pointer(0, 64);141 LLT s64 = LLT::scalar(64);142 143 // Typical RISCy set of operations based on AArch64.144 LegacyInfo.setAction({G_PTRTOINT, 0, s64}, LegacyLegalizeActions::Legal);145 LegacyInfo.setAction({G_PTRTOINT, 1, p0}, LegacyLegalizeActions::Legal);146 147 LegacyInfo.setLegalizeScalarToDifferentSizeStrategy(148 G_PTRTOINT, 0, LegacyLegalizerInfo::widenToLargerTypesAndNarrowToLargest);149 150 LegacyInfo.computeTables();151 152 // Check we infer the correct types and actually do what we're told.153 EXPECT_EQ(L.getAction({G_PTRTOINT, {s64, p0}}),154 LegalizeActionStep(Legal, 0, LLT{}));155 156 // Make sure we also handle unusual sizes157 EXPECT_EQ(158 L.getAction({G_PTRTOINT, {LLT::scalar(65), s64}}),159 LegalizeActionStep(NarrowScalar, 0, s64));160 EXPECT_EQ(161 L.getAction({G_PTRTOINT, {s64, LLT::pointer(0, 32)}}),162 LegalizeActionStep(Unsupported, 1, LLT::pointer(0, 32)));163}164 165TEST(LegalizerInfoTest, MultipleSteps) {166 using namespace TargetOpcode;167 LegalizerInfo L;168 auto &LegacyInfo = L.getLegacyLegalizerInfo();169 LLT s32 = LLT::scalar(32);170 LLT s64 = LLT::scalar(64);171 172 LegacyInfo.setLegalizeScalarToDifferentSizeStrategy(173 G_UREM, 0, LegacyLegalizerInfo::widenToLargerTypesUnsupportedOtherwise);174 LegacyInfo.setAction({G_UREM, 0, s32}, LegacyLegalizeActions::Lower);175 LegacyInfo.setAction({G_UREM, 0, s64}, LegacyLegalizeActions::Lower);176 177 LegacyInfo.computeTables();178 179 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(16)}}),180 LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));181 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(32)}}),182 LegalizeActionStep(Lower, 0, LLT::scalar(32)));183}184 185TEST(LegalizerInfoTest, SizeChangeStrategy) {186 using namespace TargetOpcode;187 LegalizerInfo L;188 auto &LegacyInfo = L.getLegacyLegalizerInfo();189 for (unsigned Size : {1, 8, 16, 32})190 LegacyInfo.setAction({G_UREM, 0, LLT::scalar(Size)},191 LegacyLegalizeActions::Legal);192 193 LegacyInfo.setLegalizeScalarToDifferentSizeStrategy(194 G_UREM, 0, LegacyLegalizerInfo::widenToLargerTypesUnsupportedOtherwise);195 LegacyInfo.computeTables();196 197 // Check we infer the correct types and actually do what we're told.198 for (unsigned Size : {1, 8, 16, 32}) {199 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(Size)}}),200 LegalizeActionStep(Legal, 0, LLT{}));201 }202 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(2)}}),203 LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));204 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(7)}}),205 LegalizeActionStep(WidenScalar, 0, LLT::scalar(8)));206 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(9)}}),207 LegalizeActionStep(WidenScalar, 0, LLT::scalar(16)));208 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(17)}}),209 LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));210 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(31)}}),211 LegalizeActionStep(WidenScalar, 0, LLT::scalar(32)));212 EXPECT_EQ(L.getAction({G_UREM, {LLT::scalar(33)}}),213 LegalizeActionStep(Unsupported, 0, LLT::scalar(33)));214}215}216 217#define EXPECT_ACTION(Action, Index, Type, Query) \218 do { \219 auto A = LI.getAction(Query); \220 EXPECT_EQ(LegalizeActionStep(Action, Index, Type), A) << A; \221 } while (0)222 223TEST(LegalizerInfoTest, RuleSets) {224 using namespace TargetOpcode;225 226 const LLT s5 = LLT::scalar(5);227 const LLT s8 = LLT::scalar(8);228 const LLT s16 = LLT::scalar(16);229 const LLT s32 = LLT::scalar(32);230 const LLT s33 = LLT::scalar(33);231 const LLT s64 = LLT::scalar(64);232 233 const LLT v2s5 = LLT::fixed_vector(2, 5);234 const LLT v2s8 = LLT::fixed_vector(2, 8);235 const LLT v2s16 = LLT::fixed_vector(2, 16);236 const LLT v2s32 = LLT::fixed_vector(2, 32);237 const LLT v3s32 = LLT::fixed_vector(3, 32);238 const LLT v4s32 = LLT::fixed_vector(4, 32);239 const LLT v8s32 = LLT::fixed_vector(8, 32);240 const LLT v2s33 = LLT::fixed_vector(2, 33);241 const LLT v2s64 = LLT::fixed_vector(2, 64);242 243 const LLT p0 = LLT::pointer(0, 32);244 const LLT v2p0 = LLT::fixed_vector(2, p0);245 const LLT v3p0 = LLT::fixed_vector(3, p0);246 const LLT v4p0 = LLT::fixed_vector(4, p0);247 248 const LLT s1 = LLT::scalar(1);249 const LLT v2s1 = LLT::fixed_vector(2, 1);250 const LLT v4s1 = LLT::fixed_vector(4, 1);251 252 {253 LegalizerInfo LI;254 auto &LegacyInfo = LI.getLegacyLegalizerInfo();255 256 LI.getActionDefinitionsBuilder(G_IMPLICIT_DEF)257 .legalFor({v4s32, v4p0})258 .moreElementsToNextPow2(0);259 LegacyInfo.computeTables();260 261 EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_IMPLICIT_DEF, {s32}));262 EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_IMPLICIT_DEF, {v2s32}));263 EXPECT_ACTION(MoreElements, 0, v4p0, LegalityQuery(G_IMPLICIT_DEF, {v3p0}));264 EXPECT_ACTION(MoreElements, 0, v4s32, LegalityQuery(G_IMPLICIT_DEF, {v3s32}));265 }266 267 // Test minScalarOrElt268 {269 LegalizerInfo LI;270 auto &LegacyInfo = LI.getLegacyLegalizerInfo();271 LI.getActionDefinitionsBuilder(G_OR)272 .legalFor({s32})273 .minScalarOrElt(0, s32);274 LegacyInfo.computeTables();275 276 EXPECT_ACTION(WidenScalar, 0, s32, LegalityQuery(G_OR, {s16}));277 EXPECT_ACTION(WidenScalar, 0, v2s32, LegalityQuery(G_OR, {v2s16}));278 }279 280 // Test maxScalarOrELt281 {282 LegalizerInfo LI;283 auto &LegacyInfo = LI.getLegacyLegalizerInfo();284 LI.getActionDefinitionsBuilder(G_AND)285 .legalFor({s16})286 .maxScalarOrElt(0, s16);287 LegacyInfo.computeTables();288 289 EXPECT_ACTION(NarrowScalar, 0, s16, LegalityQuery(G_AND, {s32}));290 EXPECT_ACTION(NarrowScalar, 0, v2s16, LegalityQuery(G_AND, {v2s32}));291 }292 293 // Test clampScalarOrElt294 {295 LegalizerInfo LI;296 auto &LegacyInfo = LI.getLegacyLegalizerInfo();297 LI.getActionDefinitionsBuilder(G_XOR)298 .legalFor({s16})299 .clampScalarOrElt(0, s16, s32);300 LegacyInfo.computeTables();301 302 EXPECT_ACTION(NarrowScalar, 0, s32, LegalityQuery(G_XOR, {s64}));303 EXPECT_ACTION(WidenScalar, 0, s16, LegalityQuery(G_XOR, {s8}));304 305 // Make sure the number of elements is preserved.306 EXPECT_ACTION(NarrowScalar, 0, v2s32, LegalityQuery(G_XOR, {v2s64}));307 EXPECT_ACTION(WidenScalar, 0, v2s16, LegalityQuery(G_XOR, {v2s8}));308 }309 310 // Test minScalar311 {312 LegalizerInfo LI;313 auto &LegacyInfo = LI.getLegacyLegalizerInfo();314 LI.getActionDefinitionsBuilder(G_OR)315 .legalFor({s32})316 .minScalar(0, s32);317 LegacyInfo.computeTables();318 319 // Only handle scalars, ignore vectors.320 EXPECT_ACTION(WidenScalar, 0, s32, LegalityQuery(G_OR, {s16}));321 EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_OR, {v2s16}));322 }323 324 // Test minScalarIf325 {326 bool IfCond = true;327 LegalizerInfo LI;328 auto &LegacyInfo = LI.getLegacyLegalizerInfo();329 LI.getActionDefinitionsBuilder(G_OR)330 .legalFor({s32})331 .minScalarIf([&](const LegalityQuery &Query) {332 return IfCond;333 }, 0, s32);334 LegacyInfo.computeTables();335 336 // Only handle scalars, ignore vectors.337 EXPECT_ACTION(WidenScalar, 0, s32, LegalityQuery(G_OR, {s16}));338 EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_OR, {v2s16}));339 340 IfCond = false;341 EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_OR, {s16}));342 EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_OR, {v2s16}));343 }344 345 // Test maxScalar346 {347 LegalizerInfo LI;348 auto &LegacyInfo = LI.getLegacyLegalizerInfo();349 LI.getActionDefinitionsBuilder(G_AND)350 .legalFor({s16})351 .maxScalar(0, s16);352 LegacyInfo.computeTables();353 354 // Only handle scalars, ignore vectors.355 EXPECT_ACTION(NarrowScalar, 0, s16, LegalityQuery(G_AND, {s32}));356 EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_AND, {v2s32}));357 }358 359 // Test clampScalar360 {361 LegalizerInfo LI;362 auto &LegacyInfo = LI.getLegacyLegalizerInfo();363 364 LI.getActionDefinitionsBuilder(G_XOR)365 .legalFor({s16})366 .clampScalar(0, s16, s32);367 LegacyInfo.computeTables();368 369 EXPECT_ACTION(NarrowScalar, 0, s32, LegalityQuery(G_XOR, {s64}));370 EXPECT_ACTION(WidenScalar, 0, s16, LegalityQuery(G_XOR, {s8}));371 372 // Only handle scalars, ignore vectors.373 EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_XOR, {v2s64}));374 EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_XOR, {v2s8}));375 }376 377 // Test widenScalarOrEltToNextPow2378 {379 LegalizerInfo LI;380 auto &LegacyInfo = LI.getLegacyLegalizerInfo();381 382 LI.getActionDefinitionsBuilder(G_AND)383 .legalFor({s32})384 .widenScalarOrEltToNextPow2(0, 32);385 LegacyInfo.computeTables();386 387 // Handle scalars and vectors388 EXPECT_ACTION(WidenScalar, 0, s32, LegalityQuery(G_AND, {s5}));389 EXPECT_ACTION(WidenScalar, 0, v2s32, LegalityQuery(G_AND, {v2s5}));390 EXPECT_ACTION(WidenScalar, 0, s64, LegalityQuery(G_AND, {s33}));391 EXPECT_ACTION(WidenScalar, 0, v2s64, LegalityQuery(G_AND, {v2s33}));392 }393 394 // Test widenScalarToNextPow2395 {396 LegalizerInfo LI;397 auto &LegacyInfo = LI.getLegacyLegalizerInfo();398 399 LI.getActionDefinitionsBuilder(G_AND)400 .legalFor({s32})401 .widenScalarToNextPow2(0, 32);402 LegacyInfo.computeTables();403 404 EXPECT_ACTION(WidenScalar, 0, s32, LegalityQuery(G_AND, {s5}));405 EXPECT_ACTION(WidenScalar, 0, s64, LegalityQuery(G_AND, {s33}));406 407 // Do nothing for vectors.408 EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_AND, {v2s5}));409 EXPECT_ACTION(Unsupported, 0, LLT(), LegalityQuery(G_AND, {v2s33}));410 }411 412 // Test changeElementCountTo413 {414 LegalizerInfo LI;415 auto &LegacyInfo = LI.getLegacyLegalizerInfo();416 417 // Type index form418 LI.getActionDefinitionsBuilder(G_SELECT)419 .moreElementsIf(isScalar(1), changeElementCountTo(1, 0));420 421 // Raw type form422 LI.getActionDefinitionsBuilder(G_ADD)423 .fewerElementsIf(typeIs(0, v4s32),424 changeElementCountTo(0, ElementCount::getFixed(2)))425 .fewerElementsIf(typeIs(0, v8s32),426 changeElementCountTo(0, ElementCount::getFixed(1)))427 .fewerElementsIf(typeIs(0, LLT::scalable_vector(4, s16)),428 changeElementCountTo(0, ElementCount::getScalable(2)))429 .fewerElementsIf(typeIs(0, LLT::scalable_vector(8, s16)),430 changeElementCountTo(0, ElementCount::getFixed(1)));431 432 LegacyInfo.computeTables();433 434 EXPECT_ACTION(MoreElements, 1, v4s1, LegalityQuery(G_SELECT, {v4s32, s1}));435 EXPECT_ACTION(MoreElements, 1, v2s1, LegalityQuery(G_SELECT, {v2s32, s1}));436 EXPECT_ACTION(MoreElements, 1, v2s1, LegalityQuery(G_SELECT, {v2s32, s1}));437 EXPECT_ACTION(MoreElements, 1, v4s1, LegalityQuery(G_SELECT, {v4p0, s1}));438 439 EXPECT_ACTION(MoreElements, 1, LLT::scalable_vector(2, 1),440 LegalityQuery(G_SELECT, {LLT::scalable_vector(2, 32), s1}));441 EXPECT_ACTION(MoreElements, 1, LLT::scalable_vector(4, 1),442 LegalityQuery(G_SELECT, {LLT::scalable_vector(4, 32), s1}));443 EXPECT_ACTION(MoreElements, 1, LLT::scalable_vector(2, s1),444 LegalityQuery(G_SELECT, {LLT::scalable_vector(2, p0), s1}));445 446 EXPECT_ACTION(FewerElements, 0, v2s32, LegalityQuery(G_ADD, {v4s32}));447 EXPECT_ACTION(FewerElements, 0, s32, LegalityQuery(G_ADD, {v8s32}));448 449 EXPECT_ACTION(FewerElements, 0, LLT::scalable_vector(2, 16),450 LegalityQuery(G_ADD, {LLT::scalable_vector(4, 16)}));451 EXPECT_ACTION(FewerElements, 0, s16,452 LegalityQuery(G_ADD, {LLT::scalable_vector(8, 16)}));453 }454 455 // Test minScalarEltSameAsIf456 {457 LegalizerInfo LI;458 auto &LegacyInfo = LI.getLegacyLegalizerInfo();459 460 LI.getActionDefinitionsBuilder(G_SELECT).minScalarEltSameAsIf(461 all(isVector(0), isVector(1)), 1, 0);462 LegacyInfo.computeTables();463 LLT p1 = LLT::pointer(1, 32);464 LLT v2p1 = LLT::fixed_vector(2, p1);465 466 EXPECT_ACTION(WidenScalar, 1, v2s32, LegalityQuery(G_SELECT, {v2p0, v2s1}));467 EXPECT_ACTION(WidenScalar, 1, v2s32, LegalityQuery(G_SELECT, {v2p1, v2s1}));468 }469}470 471TEST(LegalizerInfoTest, MMOAlignment) {472 using namespace TargetOpcode;473 474 const LLT s32 = LLT::scalar(32);475 const LLT p0 = LLT::pointer(0, 64);476 477 {478 LegalizerInfo LI;479 auto &LegacyInfo = LI.getLegacyLegalizerInfo();480 LI.getActionDefinitionsBuilder(G_LOAD)481 .legalForTypesWithMemDesc({{s32, p0, s32, 32}});482 483 LegacyInfo.computeTables();484 485 EXPECT_ACTION(486 Legal, 0, LLT(),487 LegalityQuery(G_LOAD, {s32, p0},488 LegalityQuery::MemDesc{s32, 32, AtomicOrdering::NotAtomic,489 AtomicOrdering::NotAtomic}));490 EXPECT_ACTION(491 Unsupported, 0, LLT(),492 LegalityQuery(G_LOAD, {s32, p0},493 LegalityQuery::MemDesc{s32, 16, AtomicOrdering::NotAtomic,494 AtomicOrdering::NotAtomic}));495 EXPECT_ACTION(496 Unsupported, 0, LLT(),497 LegalityQuery(G_LOAD, {s32, p0},498 LegalityQuery::MemDesc{s32, 8, AtomicOrdering::NotAtomic,499 AtomicOrdering::NotAtomic}));500 }501 502 // Test that the maximum supported alignment value isn't truncated503 {504 // Maximum IR defined alignment in bytes.505 const uint64_t MaxAlignment = UINT64_C(1) << 29;506 const uint64_t MaxAlignInBits = 8 * MaxAlignment;507 LegalizerInfo LI;508 auto &LegacyInfo = LI.getLegacyLegalizerInfo();509 LI.getActionDefinitionsBuilder(G_LOAD)510 .legalForTypesWithMemDesc({{s32, p0, s32, MaxAlignInBits}});511 512 LegacyInfo.computeTables();513 514 EXPECT_ACTION(515 Legal, 0, LLT(),516 LegalityQuery(G_LOAD, {s32, p0},517 LegalityQuery::MemDesc{s32, MaxAlignInBits,518 AtomicOrdering::NotAtomic,519 AtomicOrdering::NotAtomic}));520 EXPECT_ACTION(521 Unsupported, 0, LLT(),522 LegalityQuery(G_LOAD, {s32, p0},523 LegalityQuery::MemDesc{s32, 8, AtomicOrdering::NotAtomic,524 AtomicOrdering::NotAtomic}));525 }526}527 528// This code sequence doesn't do anything, but it covers a previously uncovered529// codepath that used to crash in MSVC x86_32 debug mode.530TEST(LegalizerInfoTest, MSVCDebugMiscompile) {531 const LLT S1 = LLT::scalar(1);532 const LLT P0 = LLT::pointer(0, 32);533 LegalizerInfo LI;534 auto Builder = LI.getActionDefinitionsBuilder(TargetOpcode::G_PTRTOINT);535 (void)Builder.legalForCartesianProduct({S1}, {P0});536}537