811 lines · cpp
1//===- ConstantRangeTest.cpp - ConstantRange tests ------------------------===//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/IR/DataLayout.h"10#include "llvm/IR/GlobalVariable.h"11#include "llvm/IR/LLVMContext.h"12#include "llvm/IR/Module.h"13#include "llvm/IR/Type.h"14#include "llvm/TargetParser/Triple.h"15#include "llvm/Testing/Support/Error.h"16#include "gtest/gtest.h"17 18using namespace llvm;19 20namespace {21 22class DataLayoutTest : public ::testing::Test {};23 24TEST(DataLayout, LayoutStringFormat) {25 for (StringRef Str : {"", "e", "m:e", "m:e-e"})26 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), Succeeded());27 28 for (StringRef Str : {"-", "e-", "-m:e", "m:e--e"})29 EXPECT_THAT_EXPECTED(30 DataLayout::parse(Str),31 FailedWithMessage("empty specification is not allowed"));32}33 34TEST(DataLayoutTest, InvalidSpecifier) {35 EXPECT_THAT_EXPECTED(DataLayout::parse("^"),36 FailedWithMessage("unknown specifier '^'"));37 EXPECT_THAT_EXPECTED(DataLayout::parse("I8:8"),38 FailedWithMessage("unknown specifier 'I'"));39 EXPECT_THAT_EXPECTED(DataLayout::parse("e-X"),40 FailedWithMessage("unknown specifier 'X'"));41 EXPECT_THAT_EXPECTED(DataLayout::parse("p0:32:32-64"),42 FailedWithMessage("unknown specifier '6'"));43}44 45TEST(DataLayoutTest, ParseEndianness) {46 EXPECT_THAT_EXPECTED(DataLayout::parse("e"), Succeeded());47 EXPECT_THAT_EXPECTED(DataLayout::parse("E"), Succeeded());48 49 for (StringRef Str : {"ee", "e0", "e:0", "E0:E", "El", "E:B"})50 EXPECT_THAT_EXPECTED(51 DataLayout::parse(Str),52 FailedWithMessage("malformed specification, must be just 'e' or 'E'"));53}54 55TEST(DataLayoutTest, ParseMangling) {56 for (StringRef Str : {"m:a", "m:e", "m:l", "m:m", "m:o", "m:w", "m:x"})57 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), Succeeded());58 59 for (StringRef Str : {"m", "ms:m", "m:"})60 EXPECT_THAT_EXPECTED(61 DataLayout::parse(Str),62 FailedWithMessage(63 "malformed specification, must be of the form \"m:<mangling>\""));64 65 for (StringRef Str : {"m:ms", "m:E", "m:0"})66 EXPECT_THAT_EXPECTED(DataLayout::parse(Str),67 FailedWithMessage("unknown mangling mode"));68}69 70TEST(DataLayoutTest, ParseStackNaturalAlign) {71 for (StringRef Str : {"S8", "S32768"})72 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), Succeeded());73 74 EXPECT_THAT_EXPECTED(75 DataLayout::parse("S"),76 FailedWithMessage(77 "malformed specification, must be of the form \"S<size>\""));78 79 for (StringRef Str : {"SX", "S0x20", "S65536"})80 EXPECT_THAT_EXPECTED(81 DataLayout::parse(Str),82 FailedWithMessage("stack natural alignment must be a 16-bit integer"));83 84 EXPECT_THAT_EXPECTED(85 DataLayout::parse("S0"),86 FailedWithMessage("stack natural alignment must be non-zero"));87 88 for (StringRef Str : {"S1", "S7", "S24", "S65535"})89 EXPECT_THAT_EXPECTED(90 DataLayout::parse(Str),91 FailedWithMessage("stack natural alignment must be a power of two "92 "times the byte width"));93}94 95TEST(DataLayoutTest, ParseAddrSpace) {96 for (StringRef Str : {"P0", "A0", "G0", "P1", "A1", "G1", "P16777215",97 "A16777215", "G16777215"})98 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), Succeeded());99 100 for (StringRef Str : {"P", "A", "G"})101 EXPECT_THAT_EXPECTED(102 DataLayout::parse(Str),103 FailedWithMessage(("malformed specification, must be of the form \"" +104 Twine(Str.front()) + "<address space>\"")105 .str()));106 107 for (StringRef Str : {"Px", "A0x1", "G16777216"})108 EXPECT_THAT_EXPECTED(109 DataLayout::parse(Str),110 FailedWithMessage("address space must be a 24-bit integer"));111}112 113TEST(DataLayoutTest, ParseFuncPtrSpec) {114 for (StringRef Str : {"Fi8", "Fn16", "Fi32768", "Fn32768"})115 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), Succeeded());116 117 EXPECT_THAT_EXPECTED(118 DataLayout::parse("F"),119 FailedWithMessage(120 "malformed specification, must be of the form \"F<type><abi>\""));121 122 EXPECT_THAT_EXPECTED(123 DataLayout::parse("FN"),124 FailedWithMessage("unknown function pointer alignment type 'N'"));125 EXPECT_THAT_EXPECTED(126 DataLayout::parse("F32"),127 FailedWithMessage("unknown function pointer alignment type '3'"));128 129 for (StringRef Str : {"Fi", "Fn"})130 EXPECT_THAT_EXPECTED(131 DataLayout::parse(Str),132 FailedWithMessage("ABI alignment component cannot be empty"));133 134 for (StringRef Str : {"Fii", "Fn32x", "Fi65536", "Fn65536"})135 EXPECT_THAT_EXPECTED(136 DataLayout::parse(Str),137 FailedWithMessage("ABI alignment must be a 16-bit integer"));138 139 for (StringRef Str : {"Fi0", "Fn0"})140 EXPECT_THAT_EXPECTED(DataLayout::parse(Str),141 FailedWithMessage("ABI alignment must be non-zero"));142 143 for (StringRef Str : {"Fi12", "Fn24"})144 EXPECT_THAT_EXPECTED(145 DataLayout::parse(Str),146 FailedWithMessage(147 "ABI alignment must be a power of two times the byte width"));148}149 150class DataLayoutPrimitiveSpecificationTest151 : public DataLayoutTest,152 public ::testing::WithParamInterface<char> {153 char Specifier;154 155public:156 DataLayoutPrimitiveSpecificationTest() : Specifier(GetParam()) {}157 158 std::string format(StringRef Str) const {159 std::string Res = Str.str();160 llvm::replace(Res, '!', Specifier);161 return Res;162 }163};164 165INSTANTIATE_TEST_SUITE_P(PrmitiveSpecifiers,166 DataLayoutPrimitiveSpecificationTest,167 ::testing::Values('i', 'f', 'v'));168 169TEST_P(DataLayoutPrimitiveSpecificationTest, ParsePrimitiveSpec) {170 for (StringRef Str :171 {"!1:16", "!8:8:8", "!16:32:64", "!16777215:32768:32768"})172 EXPECT_THAT_EXPECTED(DataLayout::parse(format(Str)), Succeeded());173 174 for (StringRef Str : {"!", "!1", "!32:32:32:32", "!16:32:64:128"})175 EXPECT_THAT_EXPECTED(176 DataLayout::parse(format(Str)),177 FailedWithMessage(format("malformed specification, must be of the form "178 "\"!<size>:<abi>[:<pref>]\"")));179 180 // size181 for (StringRef Str : {"!:8", "!:16:16", "!:32:64"})182 EXPECT_THAT_EXPECTED(DataLayout::parse(format(Str)),183 FailedWithMessage("size component cannot be empty"));184 185 for (StringRef Str :186 {"!0:8", "!0x8:8", "!x:8:8", "!0:16:32", "!16777216:64:64"})187 EXPECT_THAT_EXPECTED(188 DataLayout::parse(format(Str)),189 FailedWithMessage("size must be a non-zero 24-bit integer"));190 191 // ABI alignment192 for (StringRef Str : {"!8:", "!16::16", "!32::64"})193 EXPECT_THAT_EXPECTED(194 DataLayout::parse(format(Str)),195 FailedWithMessage("ABI alignment component cannot be empty"));196 197 for (StringRef Str : {"!1:x", "!8:8x:8", "!16:65536:65536"})198 EXPECT_THAT_EXPECTED(199 DataLayout::parse(format(Str)),200 FailedWithMessage("ABI alignment must be a 16-bit integer"));201 202 for (StringRef Str : {"!8:0", "!16:0:16", "!32:0:64"})203 EXPECT_THAT_EXPECTED(DataLayout::parse(format(Str)),204 FailedWithMessage("ABI alignment must be non-zero"));205 206 for (StringRef Str : {"!1:1", "!8:4", "!16:6:16", "!32:24:64"})207 EXPECT_THAT_EXPECTED(208 DataLayout::parse(format(Str)),209 FailedWithMessage(210 "ABI alignment must be a power of two times the byte width"));211 212 // preferred alignment213 for (StringRef Str : {"!1:8:", "!16:16:", "!64:32:"})214 EXPECT_THAT_EXPECTED(215 DataLayout::parse(format(Str)),216 FailedWithMessage("preferred alignment component cannot be empty"));217 218 for (StringRef Str : {"!1:8:x", "!8:8:0x8", "!16:32:65536"})219 EXPECT_THAT_EXPECTED(220 DataLayout::parse(format(Str)),221 FailedWithMessage("preferred alignment must be a 16-bit integer"));222 223 for (StringRef Str : {"!8:8:0", "!32:16:0"})224 EXPECT_THAT_EXPECTED(225 DataLayout::parse(format(Str)),226 FailedWithMessage("preferred alignment must be non-zero"));227 228 for (StringRef Str : {"!1:8:12", "!8:8:17", "!16:32:40"})229 EXPECT_THAT_EXPECTED(230 DataLayout::parse(format(Str)),231 FailedWithMessage(232 "preferred alignment must be a power of two times the byte width"));233 234 for (StringRef Str : {"!1:16:8", "!64:32:16"})235 EXPECT_THAT_EXPECTED(236 DataLayout::parse(format(Str)),237 FailedWithMessage(238 "preferred alignment cannot be less than the ABI alignment"));239 240 // Additional check for byte-sized integer.241 if (GetParam() == 'i') {242 for (StringRef Str : {"!8:16", "!8:16:8", "!8:16:32"})243 EXPECT_THAT_EXPECTED(DataLayout::parse(format(Str)),244 FailedWithMessage("i8 must be 8-bit aligned"));245 }246}247 248TEST(DataLayoutTest, ParseAggregateSpec) {249 for (StringRef Str : {"a:8", "a:0:16", "a0:32:64", "a:32768:32768"})250 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), Succeeded());251 252 for (StringRef Str : {"a", "a0", "a:32:32:32", "a0:32:64:128"})253 EXPECT_THAT_EXPECTED(254 DataLayout::parse(Str),255 FailedWithMessage("malformed specification, must be of the form "256 "\"a:<abi>[:<pref>]\""));257 258 // size259 for (StringRef Str : {"a1:8", "a0x0:8", "ax:16:32"})260 EXPECT_THAT_EXPECTED(DataLayout::parse(Str),261 FailedWithMessage("size must be zero"));262 263 // ABI alignment264 for (StringRef Str : {"a:", "a0:", "a::32"})265 EXPECT_THAT_EXPECTED(266 DataLayout::parse(Str),267 FailedWithMessage("ABI alignment component cannot be empty"));268 269 for (StringRef Str : {"a:x", "a0:0x0", "a:65536", "a0:65536:65536"})270 EXPECT_THAT_EXPECTED(271 DataLayout::parse(Str),272 FailedWithMessage("ABI alignment must be a 16-bit integer"));273 274 for (StringRef Str : {"a:1", "a:4", "a:9:16", "a0:24:32"})275 EXPECT_THAT_EXPECTED(276 DataLayout::parse(Str),277 FailedWithMessage(278 "ABI alignment must be a power of two times the byte width"));279 280 // preferred alignment281 for (StringRef Str : {"a:8:", "a0:16:", "a0:0:"})282 EXPECT_THAT_EXPECTED(283 DataLayout::parse(Str),284 FailedWithMessage("preferred alignment component cannot be empty"));285 286 for (StringRef Str : {"a:16:x", "a0:8:0x8", "a:16:65536"})287 EXPECT_THAT_EXPECTED(288 DataLayout::parse(Str),289 FailedWithMessage("preferred alignment must be a 16-bit integer"));290 291 for (StringRef Str : {"a:0:0", "a0:16:0"})292 EXPECT_THAT_EXPECTED(293 DataLayout::parse(Str),294 FailedWithMessage("preferred alignment must be non-zero"));295 296 for (StringRef Str : {"a:8:12", "a:16:17", "a0:32:40"})297 EXPECT_THAT_EXPECTED(298 DataLayout::parse(Str),299 FailedWithMessage(300 "preferred alignment must be a power of two times the byte width"));301 302 for (StringRef Str : {"a:16:8", "a0:32:16"})303 EXPECT_THAT_EXPECTED(304 DataLayout::parse(Str),305 FailedWithMessage(306 "preferred alignment cannot be less than the ABI alignment"));307}308 309TEST(DataLayout, ParsePointerSpec) {310 for (StringRef Str :311 {"p:16:8", "p:16:16:64", "p:32:64:64:32", "p0:32:64", "p42:64:32:32",312 "p16777215:32:32:64:8", "p16777215:16777215:32768:32768:16777215"})313 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), Succeeded());314 315 for (StringRef Str :316 {"p", "p0", "p:32", "p0:32", "p:32:32:32:32:32", "p0:32:32:32:32:32"})317 EXPECT_THAT_EXPECTED(318 DataLayout::parse(Str),319 FailedWithMessage("malformed specification, must be of the form "320 "\"p[<n>]:<size>:<abi>[:<pref>[:<idx>]]\""));321 322 // address space323 for (StringRef Str :324 {"p0x0:32:32", "p10_000:32:32:32", "p16777216:32:32:32:32"})325 EXPECT_THAT_EXPECTED(326 DataLayout::parse(Str),327 FailedWithMessage("address space must be a 24-bit integer"));328 329 // pointer size330 for (StringRef Str : {"p::32", "p0::32"})331 EXPECT_THAT_EXPECTED(332 DataLayout::parse(Str),333 FailedWithMessage("pointer size component cannot be empty"));334 335 for (StringRef Str : {"p:0:32", "p0:0x1:32:32", "p42:16777216:32:32:32"})336 EXPECT_THAT_EXPECTED(337 DataLayout::parse(Str),338 FailedWithMessage("pointer size must be a non-zero 24-bit integer"));339 340 // ABI alignment341 for (StringRef Str : {"p:32:", "p0:32::32", "p42:32::32:32"})342 EXPECT_THAT_EXPECTED(343 DataLayout::parse(Str),344 FailedWithMessage("ABI alignment component cannot be empty"));345 346 for (StringRef Str : {"p:32:x", "p0:32:0x20:32", "p42:32:65536:32:32"})347 EXPECT_THAT_EXPECTED(348 DataLayout::parse(Str),349 FailedWithMessage("ABI alignment must be a 16-bit integer"));350 351 for (StringRef Str : {"p:32:0", "p0:32:0:32", "p42:32:0:32:32"})352 EXPECT_THAT_EXPECTED(DataLayout::parse(Str),353 FailedWithMessage("ABI alignment must be non-zero"));354 355 for (StringRef Str : {"p:32:4", "p42:32:24:32", "p0:32:65535:32:32"})356 EXPECT_THAT_EXPECTED(357 DataLayout::parse(Str),358 FailedWithMessage(359 "ABI alignment must be a power of two times the byte width"));360 361 // preferred alignment362 for (StringRef Str : {"p:32:32:", "p0:32:32:", "p42:32:32::32"})363 EXPECT_THAT_EXPECTED(364 DataLayout::parse(Str),365 FailedWithMessage("preferred alignment component cannot be empty"));366 367 for (StringRef Str : {"p:32:32:x", "p0:32:32:0x20", "p42:32:32:65536:32"})368 EXPECT_THAT_EXPECTED(369 DataLayout::parse(Str),370 FailedWithMessage("preferred alignment must be a 16-bit integer"));371 372 for (StringRef Str : {"p:32:32:0", "p0:32:32:0", "p42:32:32:0:32"})373 EXPECT_THAT_EXPECTED(374 DataLayout::parse(Str),375 FailedWithMessage("preferred alignment must be non-zero"));376 377 for (StringRef Str : {"p:32:32:4", "p0:32:32:24", "p42:32:32:65535:32"})378 EXPECT_THAT_EXPECTED(379 DataLayout::parse(Str),380 FailedWithMessage(381 "preferred alignment must be a power of two times the byte width"));382 383 for (StringRef Str : {"p:64:64:32", "p0:16:32:16:16"})384 EXPECT_THAT_EXPECTED(385 DataLayout::parse(Str),386 FailedWithMessage(387 "preferred alignment cannot be less than the ABI alignment"));388 389 // index size390 for (StringRef Str : {"p:32:32:32:", "p0:32:32:32:"})391 EXPECT_THAT_EXPECTED(392 DataLayout::parse(Str),393 FailedWithMessage("index size component cannot be empty"));394 395 for (StringRef Str :396 {"p:32:32:32:0", "p0:32:32:32:0x20", "p42:32:32:32:16777216"})397 EXPECT_THAT_EXPECTED(398 DataLayout::parse(Str),399 FailedWithMessage("index size must be a non-zero 24-bit integer"));400 401 for (StringRef Str : {"p:16:16:16:17", "p0:32:64:64:64", "p42:16:64:64:32"})402 EXPECT_THAT_EXPECTED(403 DataLayout::parse(Str),404 FailedWithMessage("index size cannot be larger than the pointer size"));405 406 // Only 'e', 'u', and 'n' flags are valid.407 EXPECT_THAT_EXPECTED(408 DataLayout::parse("pa:32:32"),409 FailedWithMessage("'a' is not a valid pointer specification flag"));410 EXPECT_THAT_EXPECTED(411 DataLayout::parse("puX:32:32"),412 FailedWithMessage("'X' is not a valid pointer specification flag"));413 // Flags must be before the address space number.414 EXPECT_THAT_EXPECTED(415 DataLayout::parse("p2n:32:32"),416 FailedWithMessage("address space must be a 24-bit integer"));417 418 // AS0 cannot be non-integral.419 for (StringRef Str : {"pe:64:64", "pu:64:64", "pue:64:64", "pe0:64:64",420 "pu0:64:64", "peu0:64:64"})421 EXPECT_THAT_EXPECTED(422 DataLayout::parse(Str),423 FailedWithMessage(424 "address space 0 cannot be unstable or have external state"));425}426 427TEST(DataLayoutTest, ParseNativeIntegersSpec) {428 for (StringRef Str : {"n1", "n1:8", "n24:12:16777215"})429 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), Succeeded());430 431 for (StringRef Str : {"n", "n1:", "n:8", "n16::32"})432 EXPECT_THAT_EXPECTED(DataLayout::parse(Str),433 FailedWithMessage("size component cannot be empty"));434 435 for (StringRef Str : {"n0", "n0x8:16", "n8:0", "n16:0:32", "n16777216",436 "n16:16777216", "n32:64:16777216"})437 EXPECT_THAT_EXPECTED(438 DataLayout::parse(Str),439 FailedWithMessage("size must be a non-zero 24-bit integer"));440}441 442TEST(DataLayout, ParseNonIntegralAddrSpace) {443 for (StringRef Str : {"ni:1", "ni:16777215", "ni:1:16777215"})444 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), Succeeded());445 446 for (StringRef Str : {"ni", "ni42", "nix"})447 EXPECT_THAT_EXPECTED(448 DataLayout::parse(Str),449 FailedWithMessage("malformed specification, must be of the form "450 "\"ni:<address space>[:<address space>]...\""));451 452 for (StringRef Str : {"ni:", "ni::42", "ni:42:"})453 EXPECT_THAT_EXPECTED(454 DataLayout::parse(Str),455 FailedWithMessage("address space component cannot be empty"));456 457 for (StringRef Str : {"ni:x", "ni:42:0x1", "ni:16777216", "ni:42:16777216"})458 EXPECT_THAT_EXPECTED(459 DataLayout::parse(Str),460 FailedWithMessage("address space must be a 24-bit integer"));461 462 for (StringRef Str : {"ni:0", "ni:42:0"})463 EXPECT_THAT_EXPECTED(464 DataLayout::parse(Str),465 FailedWithMessage("address space 0 cannot be non-integral"));466}467 468TEST(DataLayout, GetStackAlignment) {469 DataLayout Default;470 EXPECT_FALSE(Default.getStackAlignment().has_value());471 472 std::pair<StringRef, Align> Cases[] = {473 {"S8", Align(1)},474 {"S64", Align(8)},475 {"S32768", Align(4096)},476 };477 for (auto [Layout, Val] : Cases) {478 DataLayout DL = cantFail(DataLayout::parse(Layout));479 EXPECT_EQ(DL.getStackAlignment(), Val) << Layout;480 }481}482 483TEST(DataLayout, GetPointerSizeInBits) {484 std::tuple<StringRef, unsigned, unsigned, unsigned> Cases[] = {485 {"", 64, 64, 64},486 {"p:16:32", 16, 16, 16},487 {"p0:32:64", 32, 32, 32},488 {"p1:16:32", 64, 16, 64},489 {"p1:31:32-p2:15:16:16:14", 64, 31, 15},490 };491 for (auto [Layout, V0, V1, V2] : Cases) {492 DataLayout DL = cantFail(DataLayout::parse(Layout));493 EXPECT_EQ(DL.getPointerSizeInBits(0), V0) << Layout;494 EXPECT_EQ(DL.getPointerSizeInBits(1), V1) << Layout;495 EXPECT_EQ(DL.getPointerSizeInBits(2), V2) << Layout;496 }497}498 499TEST(DataLayout, GetPointerSize) {500 std::tuple<StringRef, unsigned, unsigned, unsigned> Cases[] = {501 {"", 8, 8, 8},502 {"p:16:32", 2, 2, 2},503 {"p0:32:64", 4, 4, 4},504 {"p1:17:32", 8, 3, 8},505 {"p1:31:64-p2:23:8:16:9", 8, 4, 3},506 };507 for (auto [Layout, V0, V1, V2] : Cases) {508 DataLayout DL = cantFail(DataLayout::parse(Layout));509 EXPECT_EQ(DL.getPointerSize(0), V0) << Layout;510 EXPECT_EQ(DL.getPointerSize(1), V1) << Layout;511 EXPECT_EQ(DL.getPointerSize(2), V2) << Layout;512 }513}514 515TEST(DataLayout, GetIndexSizeInBits) {516 std::tuple<StringRef, unsigned, unsigned, unsigned> Cases[] = {517 {"", 64, 64, 64},518 {"p:16:32", 16, 16, 16},519 {"p0:32:64", 32, 32, 32},520 {"p1:16:32:32:10", 64, 10, 64},521 {"p1:31:32:64:20-p2:17:16:16:15", 64, 20, 15},522 };523 for (auto [Layout, V0, V1, V2] : Cases) {524 DataLayout DL = cantFail(DataLayout::parse(Layout));525 EXPECT_EQ(DL.getIndexSizeInBits(0), V0) << Layout;526 EXPECT_EQ(DL.getIndexSizeInBits(1), V1) << Layout;527 EXPECT_EQ(DL.getIndexSizeInBits(2), V2) << Layout;528 }529}530 531TEST(DataLayout, GetIndexSize) {532 std::tuple<StringRef, unsigned, unsigned, unsigned> Cases[] = {533 {"", 8, 8, 8},534 {"p:16:32", 2, 2, 2},535 {"p0:27:64", 4, 4, 4},536 {"p1:19:32:64:5", 8, 1, 8},537 {"p1:33:32:64:23-p2:21:8:16:13", 8, 3, 2},538 };539 for (auto [Layout, V0, V1, V2] : Cases) {540 DataLayout DL = cantFail(DataLayout::parse(Layout));541 EXPECT_EQ(DL.getIndexSize(0), V0) << Layout;542 EXPECT_EQ(DL.getIndexSize(1), V1) << Layout;543 EXPECT_EQ(DL.getIndexSize(2), V2) << Layout;544 }545}546 547TEST(DataLayout, GetPointerABIAlignment) {548 std::tuple<StringRef, unsigned, unsigned, unsigned> Cases[] = {549 {"", 8, 8, 8},550 {"p:16:32", 4, 4, 4},551 {"p0:16:32:64", 4, 4, 4},552 {"p1:32:16:64", 8, 2, 8},553 {"p1:33:16:32:15-p2:23:8:16:9", 8, 2, 1},554 };555 for (auto [Layout, V0, V1, V2] : Cases) {556 DataLayout DL = cantFail(DataLayout::parse(Layout));557 EXPECT_EQ(DL.getPointerABIAlignment(0).value(), V0) << Layout;558 EXPECT_EQ(DL.getPointerABIAlignment(1).value(), V1) << Layout;559 EXPECT_EQ(DL.getPointerABIAlignment(2).value(), V2) << Layout;560 }561}562 563TEST(DataLayout, GetPointerPrefAlignment) {564 std::tuple<StringRef, unsigned, unsigned, unsigned> Cases[] = {565 {"", 8, 8, 8},566 {"p:16:32", 4, 4, 4},567 {"p0:8:16:32", 4, 4, 4},568 {"p1:32:8:16", 8, 2, 8},569 {"p1:33:8:16:31-p2:23:8:32:17", 8, 2, 4},570 };571 for (auto [Layout, V0, V1, V2] : Cases) {572 DataLayout DL = cantFail(DataLayout::parse(Layout));573 EXPECT_EQ(DL.getPointerPrefAlignment(0).value(), V0) << Layout;574 EXPECT_EQ(DL.getPointerPrefAlignment(1).value(), V1) << Layout;575 EXPECT_EQ(DL.getPointerPrefAlignment(2).value(), V2) << Layout;576 }577}578 579TEST(DataLayout, IsNonIntegralAddressSpace) {580 const DataLayout Default;581 EXPECT_THAT(Default.getNonStandardAddressSpaces(), ::testing::SizeIs(0));582 EXPECT_FALSE(Default.isNonIntegralAddressSpace(0));583 EXPECT_FALSE(Default.isNonIntegralAddressSpace(1));584 585 const DataLayout Custom = cantFail(DataLayout::parse("ni:2:16777215"));586 EXPECT_THAT(Custom.getNonStandardAddressSpaces(),587 ::testing::ElementsAreArray({2U, 16777215U}));588 EXPECT_FALSE(Custom.isNonIntegralAddressSpace(0));589 EXPECT_FALSE(Custom.isNonIntegralAddressSpace(1));590 EXPECT_TRUE(Custom.isNonIntegralAddressSpace(2));591 EXPECT_TRUE(Custom.mustNotIntroduceIntToPtr(2));592 EXPECT_TRUE(Custom.mustNotIntroducePtrToInt(2));593 EXPECT_TRUE(Custom.isNonIntegralAddressSpace(16777215));594 EXPECT_TRUE(Custom.mustNotIntroduceIntToPtr(16777215));595 EXPECT_TRUE(Custom.mustNotIntroducePtrToInt(16777215));596 597 // Pointers are marked as non-integral if the address size != total size598 for (const auto *Layout : {"p2:64:64:64:32", "p2:128:64:64:64"}) {599 const DataLayout DL = cantFail(DataLayout::parse(Layout));600 EXPECT_TRUE(DL.isNonIntegralAddressSpace(2));601 EXPECT_FALSE(DL.hasUnstableRepresentation(2));602 EXPECT_FALSE(DL.hasExternalState(2));603 EXPECT_FALSE(DL.mustNotIntroduceIntToPtr(2));604 EXPECT_FALSE(DL.mustNotIntroducePtrToInt(2));605 EXPECT_THAT(DL.getNonStandardAddressSpaces(),606 ::testing::ElementsAreArray({2U}));607 }608 // Pointers can be marked as unstable using 'pu'609 for (const auto *Layout : {"pu2:64:64:64:64", "pu2:64:64:64:32"}) {610 const DataLayout DL = cantFail(DataLayout::parse(Layout));611 // Note: isNonIntegralAddressSpace returns true for even with index ==612 EXPECT_TRUE(DL.isNonIntegralAddressSpace(2));613 EXPECT_TRUE(DL.hasUnstableRepresentation(2));614 EXPECT_FALSE(DL.hasExternalState(2));615 EXPECT_TRUE(DL.mustNotIntroducePtrToInt(2));616 EXPECT_TRUE(DL.mustNotIntroduceIntToPtr(2));617 EXPECT_THAT(DL.getNonStandardAddressSpaces(),618 ::testing::ElementsAreArray({2U}));619 }620 621 // Non-integral pointers with external state ('e' flag).622 for (const auto *Layout : {"pe2:64:64:64:32", "pe2:64:64:64:64"}) {623 const DataLayout DL = cantFail(DataLayout::parse(Layout));624 EXPECT_TRUE(DL.isNonIntegralAddressSpace(2));625 EXPECT_TRUE(DL.hasExternalState(2));626 EXPECT_TRUE(DL.mustNotIntroduceIntToPtr(2));627 EXPECT_FALSE(DL.mustNotIntroducePtrToInt(2));628 EXPECT_FALSE(DL.hasUnstableRepresentation(2));629 EXPECT_THAT(DL.getNonStandardAddressSpaces(),630 ::testing::ElementsAreArray({2U}));631 }632 633 // It is also possible to have both unstable representation and external state634 for (const auto *Layout : {"peu2:64:64:64:32", "pue2:128:64:64:64"}) {635 const DataLayout DL = cantFail(DataLayout::parse(Layout));636 EXPECT_TRUE(DL.isNonIntegralAddressSpace(2));637 EXPECT_TRUE(DL.hasExternalState(2));638 EXPECT_TRUE(Custom.mustNotIntroduceIntToPtr(2));639 EXPECT_TRUE(Custom.mustNotIntroducePtrToInt(2));640 EXPECT_TRUE(DL.hasUnstableRepresentation(2));641 EXPECT_THAT(DL.getNonStandardAddressSpaces(),642 ::testing::ElementsAreArray({2U}));643 }644 645 // For backwards compatibility, the ni DataLayout part overrides any646 // p[e][u].647 for (const auto *Layout :648 {"ni:2-p2:64:64:64:32", "ni:2-pu2:64:64:64:32", "ni:2-pu2:64:64:64:32",649 "p2:64:64:64:32-ni:2", "pu2:64:64:64:32-ni:2", "pe2:64:64:64:32-ni:2",650 "peeee2:64:64:64:32-pu2:64:64:64:32-ni:2"}) {651 DataLayout DL = cantFail(DataLayout::parse(Layout));652 EXPECT_TRUE(DL.isNonIntegralAddressSpace(2));653 EXPECT_TRUE(DL.hasUnstableRepresentation(2));654 // The external state property is new and not expected for existing uses of655 // non-integral pointers, so existing :ni data layouts should not set it.656 EXPECT_FALSE(DL.hasExternalState(2));657 EXPECT_THAT(DL.getNonStandardAddressSpaces(),658 ::testing::ElementsAreArray({2U}));659 }660}661 662TEST(DataLayout, NonIntegralHelpers) {663 DataLayout DL = cantFail(DataLayout::parse(664 "p1:128:128:128:64-pu2:32:32:32:32-pu3:64:64:64:32-pe4:64:64:64:32"));665 EXPECT_THAT(DL.getNonStandardAddressSpaces(),666 ::testing::ElementsAreArray({1u, 2u, 3u, 4u}));667 struct Result {668 unsigned Addrspace;669 bool NonIntegral;670 bool Unstable;671 bool ExternalState;672 unsigned Size;673 } ExpectedResults[] = {674 {0, false, false, false, 64}, {1, true, false, false, 128},675 {2, true, true, false, 32}, {3, true, true, false, 64},676 {4, true, false, true, 64},677 };678 LLVMContext Ctx;679 for (const auto &Exp : ExpectedResults) {680 EXPECT_EQ(Exp.NonIntegral, DL.isNonIntegralAddressSpace(Exp.Addrspace));681 EXPECT_EQ(Exp.Unstable, DL.hasUnstableRepresentation(Exp.Addrspace));682 EXPECT_EQ(Exp.ExternalState, DL.hasExternalState(Exp.Addrspace));683 bool AvoidIntToPtr = Exp.Unstable || Exp.ExternalState;684 EXPECT_EQ(AvoidIntToPtr, DL.mustNotIntroduceIntToPtr(Exp.Addrspace));685 bool AvoidPtrToInt = Exp.Unstable;686 EXPECT_EQ(AvoidPtrToInt, DL.mustNotIntroducePtrToInt(Exp.Addrspace));687 Type *PtrTy = PointerType::get(Ctx, Exp.Addrspace);688 Type *PtrVecTy = VectorType::get(PtrTy, 2, /*Scalable=*/false);689 Type *ScalablePtrVecTy = VectorType::get(PtrTy, 1, /*Scalable=*/true);690 for (Type *Ty : {PtrTy, PtrVecTy, ScalablePtrVecTy}) {691 EXPECT_EQ(AvoidPtrToInt, DL.mustNotIntroducePtrToInt(Ty));692 EXPECT_EQ(AvoidIntToPtr, DL.mustNotIntroduceIntToPtr(Ty));693 // The old API should return true for both unstable and non-integral.694 EXPECT_EQ(Exp.Unstable || Exp.NonIntegral,695 DL.isNonIntegralPointerType(Ty));696 }697 // Both helpers gracefully handle non-pointer, non-vector-of-pointers:698 EXPECT_FALSE(DL.mustNotIntroducePtrToInt(IntegerType::getInt1Ty(Ctx)));699 EXPECT_FALSE(DL.mustNotIntroduceIntToPtr(IntegerType::getInt1Ty(Ctx)));700 }701}702 703TEST(DataLayoutTest, CopyAssignmentInvalidatesStructLayout) {704 DataLayout DL1 = cantFail(DataLayout::parse("p:32:32"));705 DataLayout DL2 = cantFail(DataLayout::parse("p:64:64"));706 707 LLVMContext Ctx;708 StructType *Ty = StructType::get(PointerType::getUnqual(Ctx));709 710 // Initialize struct layout caches.711 EXPECT_EQ(DL1.getStructLayout(Ty)->getSizeInBits(), 32U);712 EXPECT_EQ(DL1.getStructLayout(Ty)->getAlignment(), Align(4));713 EXPECT_EQ(DL2.getStructLayout(Ty)->getSizeInBits(), 64U);714 EXPECT_EQ(DL2.getStructLayout(Ty)->getAlignment(), Align(8));715 716 // The copy should invalidate DL1's cache.717 DL1 = DL2;718 EXPECT_EQ(DL1.getStructLayout(Ty)->getSizeInBits(), 64U);719 EXPECT_EQ(DL1.getStructLayout(Ty)->getAlignment(), Align(8));720 EXPECT_EQ(DL2.getStructLayout(Ty)->getSizeInBits(), 64U);721 EXPECT_EQ(DL2.getStructLayout(Ty)->getAlignment(), Align(8));722}723 724TEST(DataLayoutTest, FunctionPtrAlign) {725 EXPECT_EQ(MaybeAlign(0), DataLayout("").getFunctionPtrAlign());726 EXPECT_EQ(MaybeAlign(1), DataLayout("Fi8").getFunctionPtrAlign());727 EXPECT_EQ(MaybeAlign(2), DataLayout("Fi16").getFunctionPtrAlign());728 EXPECT_EQ(MaybeAlign(4), DataLayout("Fi32").getFunctionPtrAlign());729 EXPECT_EQ(MaybeAlign(8), DataLayout("Fi64").getFunctionPtrAlign());730 EXPECT_EQ(MaybeAlign(1), DataLayout("Fn8").getFunctionPtrAlign());731 EXPECT_EQ(MaybeAlign(2), DataLayout("Fn16").getFunctionPtrAlign());732 EXPECT_EQ(MaybeAlign(4), DataLayout("Fn32").getFunctionPtrAlign());733 EXPECT_EQ(MaybeAlign(8), DataLayout("Fn64").getFunctionPtrAlign());734 EXPECT_EQ(DataLayout::FunctionPtrAlignType::Independent,735 DataLayout("").getFunctionPtrAlignType());736 EXPECT_EQ(DataLayout::FunctionPtrAlignType::Independent,737 DataLayout("Fi8").getFunctionPtrAlignType());738 EXPECT_EQ(DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign,739 DataLayout("Fn8").getFunctionPtrAlignType());740 EXPECT_EQ(DataLayout("Fi8"), DataLayout("Fi8"));741 EXPECT_NE(DataLayout("Fi8"), DataLayout("Fi16"));742 EXPECT_NE(DataLayout("Fi8"), DataLayout("Fn8"));743 744 DataLayout a(""), b("Fi8"), c("Fn8");745 EXPECT_NE(a, b);746 EXPECT_NE(a, c);747 EXPECT_NE(b, c);748 749 a = b;750 EXPECT_EQ(a, b);751 a = c;752 EXPECT_EQ(a, c);753}754 755TEST(DataLayoutTest, ValueOrABITypeAlignment) {756 const DataLayout DL("Fi8");757 LLVMContext Context;758 Type *const FourByteAlignType = Type::getInt32Ty(Context);759 EXPECT_EQ(Align(16),760 DL.getValueOrABITypeAlignment(MaybeAlign(16), FourByteAlignType));761 EXPECT_EQ(Align(4),762 DL.getValueOrABITypeAlignment(MaybeAlign(), FourByteAlignType));763}764 765TEST(DataLayoutTest, GlobalsAddressSpace) {766 // When not explicitly defined the globals address space should be zero:767 EXPECT_EQ(DataLayout("").getDefaultGlobalsAddressSpace(), 0u);768 EXPECT_EQ(DataLayout("P1-A2").getDefaultGlobalsAddressSpace(), 0u);769 EXPECT_EQ(DataLayout("G2").getDefaultGlobalsAddressSpace(), 2u);770 // Check that creating a GlobalVariable without an explicit address space771 // in a module with a default globals address space respects that default:772 LLVMContext Context;773 std::unique_ptr<Module> M(new Module("MyModule", Context));774 // Default is globals in address space zero:775 auto *Int32 = Type::getInt32Ty(Context);776 auto *DefaultGlobal1 = new GlobalVariable(777 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr);778 EXPECT_EQ(DefaultGlobal1->getAddressSpace(), 0u);779 auto *ExplicitGlobal1 = new GlobalVariable(780 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr, "", nullptr,781 GlobalValue::NotThreadLocal, 123);782 EXPECT_EQ(ExplicitGlobal1->getAddressSpace(), 123u);783 784 // When using a datalayout with the global address space set to 200, global785 // variables should default to 200786 M->setDataLayout("G200");787 auto *DefaultGlobal2 = new GlobalVariable(788 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr);789 EXPECT_EQ(DefaultGlobal2->getAddressSpace(), 200u);790 auto *ExplicitGlobal2 = new GlobalVariable(791 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr, "", nullptr,792 GlobalValue::NotThreadLocal, 123);793 EXPECT_EQ(ExplicitGlobal2->getAddressSpace(), 123u);794}795 796TEST(DataLayoutTest, VectorAlign) {797 Expected<DataLayout> DL = DataLayout::parse("v64:64");798 EXPECT_THAT_EXPECTED(DL, Succeeded());799 800 LLVMContext Context;801 Type *const FloatTy = Type::getFloatTy(Context);802 Type *const V8F32Ty = FixedVectorType::get(FloatTy, 8);803 804 // The alignment for a vector type larger than any specified vector type uses805 // the natural alignment as a fallback.806 EXPECT_EQ(Align(4 * 8), DL->getABITypeAlign(V8F32Ty));807 EXPECT_EQ(Align(4 * 8), DL->getPrefTypeAlign(V8F32Ty));808}809 810} // anonymous namespace811