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-exception 6 // 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 18 using namespace llvm; 19 20 namespace { 21 22 class DataLayoutTest : public ::testing::Test {}; 23 24 TEST(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 34 TEST(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 45 TEST(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 55 TEST(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 70 TEST(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 95 TEST(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 113 TEST(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 150 class DataLayoutPrimitiveSpecificationTest 151 : public DataLayoutTest, 152 public ::testing::WithParamInterface<char> { 153 char Specifier; 154 155 public: 156 DataLayoutPrimitiveSpecificationTest() : Specifier(GetParam()) {} 157 158 std::string format(StringRef Str) const { 159 std::string Res = Str.str(); 160 std::replace(Res.begin(), Res.end(), '!', Specifier); 161 return Res; 162 } 163 }; 164 165 INSTANTIATE_TEST_SUITE_P(PrmitiveSpecifiers, 166 DataLayoutPrimitiveSpecificationTest, 167 ::testing::Values('i', 'f', 'v')); 168 169 TEST_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 // size 181 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 alignment 192 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 alignment 213 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 248 TEST(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 // size 259 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 alignment 264 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 alignment 281 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 309 TEST(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 space 323 for (StringRef Str : {"p0x0:32:32", "px:32:32:32", "p16777216:32:32:32:32"}) 324 EXPECT_THAT_EXPECTED( 325 DataLayout::parse(Str), 326 FailedWithMessage("address space must be a 24-bit integer")); 327 328 // pointer size 329 for (StringRef Str : {"p::32", "p0::32"}) 330 EXPECT_THAT_EXPECTED( 331 DataLayout::parse(Str), 332 FailedWithMessage("pointer size component cannot be empty")); 333 334 for (StringRef Str : {"p:0:32", "p0:0x1:32:32", "p42:16777216:32:32:32"}) 335 EXPECT_THAT_EXPECTED( 336 DataLayout::parse(Str), 337 FailedWithMessage("pointer size must be a non-zero 24-bit integer")); 338 339 // ABI alignment 340 for (StringRef Str : {"p:32:", "p0:32::32", "p42:32::32:32"}) 341 EXPECT_THAT_EXPECTED( 342 DataLayout::parse(Str), 343 FailedWithMessage("ABI alignment component cannot be empty")); 344 345 for (StringRef Str : {"p:32:x", "p0:32:0x20:32", "p42:32:65536:32:32"}) 346 EXPECT_THAT_EXPECTED( 347 DataLayout::parse(Str), 348 FailedWithMessage("ABI alignment must be a 16-bit integer")); 349 350 for (StringRef Str : {"p:32:0", "p0:32:0:32", "p42:32:0:32:32"}) 351 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), 352 FailedWithMessage("ABI alignment must be non-zero")); 353 354 for (StringRef Str : {"p:32:4", "p42:32:24:32", "p0:32:65535:32:32"}) 355 EXPECT_THAT_EXPECTED( 356 DataLayout::parse(Str), 357 FailedWithMessage( 358 "ABI alignment must be a power of two times the byte width")); 359 360 // preferred alignment 361 for (StringRef Str : {"p:32:32:", "p0:32:32:", "p42:32:32::32"}) 362 EXPECT_THAT_EXPECTED( 363 DataLayout::parse(Str), 364 FailedWithMessage("preferred alignment component cannot be empty")); 365 366 for (StringRef Str : {"p:32:32:x", "p0:32:32:0x20", "p42:32:32:65536:32"}) 367 EXPECT_THAT_EXPECTED( 368 DataLayout::parse(Str), 369 FailedWithMessage("preferred alignment must be a 16-bit integer")); 370 371 for (StringRef Str : {"p:32:32:0", "p0:32:32:0", "p42:32:32:0:32"}) 372 EXPECT_THAT_EXPECTED( 373 DataLayout::parse(Str), 374 FailedWithMessage("preferred alignment must be non-zero")); 375 376 for (StringRef Str : {"p:32:32:4", "p0:32:32:24", "p42:32:32:65535:32"}) 377 EXPECT_THAT_EXPECTED( 378 DataLayout::parse(Str), 379 FailedWithMessage( 380 "preferred alignment must be a power of two times the byte width")); 381 382 for (StringRef Str : {"p:64:64:32", "p0:16:32:16:16"}) 383 EXPECT_THAT_EXPECTED( 384 DataLayout::parse(Str), 385 FailedWithMessage( 386 "preferred alignment cannot be less than the ABI alignment")); 387 388 // index size 389 for (StringRef Str : {"p:32:32:32:", "p0:32:32:32:"}) 390 EXPECT_THAT_EXPECTED( 391 DataLayout::parse(Str), 392 FailedWithMessage("index size component cannot be empty")); 393 394 for (StringRef Str : 395 {"p:32:32:32:0", "p0:32:32:32:0x20", "p42:32:32:32:16777216"}) 396 EXPECT_THAT_EXPECTED( 397 DataLayout::parse(Str), 398 FailedWithMessage("index size must be a non-zero 24-bit integer")); 399 400 for (StringRef Str : {"p:16:16:16:17", "p0:32:64:64:64", "p42:16:64:64:32"}) 401 EXPECT_THAT_EXPECTED( 402 DataLayout::parse(Str), 403 FailedWithMessage("index size cannot be larger than the pointer size")); 404 } 405 406 TEST(DataLayoutTest, ParseNativeIntegersSpec) { 407 for (StringRef Str : {"n1", "n1:8", "n24:12:16777215"}) 408 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), Succeeded()); 409 410 for (StringRef Str : {"n", "n1:", "n:8", "n16::32"}) 411 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), 412 FailedWithMessage("size component cannot be empty")); 413 414 for (StringRef Str : {"n0", "n0x8:16", "n8:0", "n16:0:32", "n16777216", 415 "n16:16777216", "n32:64:16777216"}) 416 EXPECT_THAT_EXPECTED( 417 DataLayout::parse(Str), 418 FailedWithMessage("size must be a non-zero 24-bit integer")); 419 } 420 421 TEST(DataLayout, ParseNonIntegralAddrSpace) { 422 for (StringRef Str : {"ni:1", "ni:16777215", "ni:1:16777215"}) 423 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), Succeeded()); 424 425 for (StringRef Str : {"ni", "ni42", "nix"}) 426 EXPECT_THAT_EXPECTED( 427 DataLayout::parse(Str), 428 FailedWithMessage("malformed specification, must be of the form " 429 "\"ni:<address space>[:<address space>]...\"")); 430 431 for (StringRef Str : {"ni:", "ni::42", "ni:42:"}) 432 EXPECT_THAT_EXPECTED( 433 DataLayout::parse(Str), 434 FailedWithMessage("address space component cannot be empty")); 435 436 for (StringRef Str : {"ni:x", "ni:42:0x1", "ni:16777216", "ni:42:16777216"}) 437 EXPECT_THAT_EXPECTED( 438 DataLayout::parse(Str), 439 FailedWithMessage("address space must be a 24-bit integer")); 440 441 for (StringRef Str : {"ni:0", "ni:42:0"}) 442 EXPECT_THAT_EXPECTED( 443 DataLayout::parse(Str), 444 FailedWithMessage("address space 0 cannot be non-integral")); 445 } 446 447 TEST(DataLayout, GetStackAlignment) { 448 DataLayout Default; 449 EXPECT_FALSE(Default.getStackAlignment().has_value()); 450 451 std::pair<StringRef, Align> Cases[] = { 452 {"S8", Align(1)}, 453 {"S64", Align(8)}, 454 {"S32768", Align(4096)}, 455 }; 456 for (auto [Layout, Val] : Cases) { 457 DataLayout DL = cantFail(DataLayout::parse(Layout)); 458 EXPECT_EQ(DL.getStackAlignment(), Val) << Layout; 459 } 460 } 461 462 TEST(DataLayout, GetPointerSizeInBits) { 463 std::tuple<StringRef, unsigned, unsigned, unsigned> Cases[] = { 464 {"", 64, 64, 64}, 465 {"p:16:32", 16, 16, 16}, 466 {"p0:32:64", 32, 32, 32}, 467 {"p1:16:32", 64, 16, 64}, 468 {"p1:31:32-p2:15:16:16:14", 64, 31, 15}, 469 }; 470 for (auto [Layout, V0, V1, V2] : Cases) { 471 DataLayout DL = cantFail(DataLayout::parse(Layout)); 472 EXPECT_EQ(DL.getPointerSizeInBits(0), V0) << Layout; 473 EXPECT_EQ(DL.getPointerSizeInBits(1), V1) << Layout; 474 EXPECT_EQ(DL.getPointerSizeInBits(2), V2) << Layout; 475 } 476 } 477 478 TEST(DataLayout, GetPointerSize) { 479 std::tuple<StringRef, unsigned, unsigned, unsigned> Cases[] = { 480 {"", 8, 8, 8}, 481 {"p:16:32", 2, 2, 2}, 482 {"p0:32:64", 4, 4, 4}, 483 {"p1:17:32", 8, 3, 8}, 484 {"p1:31:64-p2:23:8:16:9", 8, 4, 3}, 485 }; 486 for (auto [Layout, V0, V1, V2] : Cases) { 487 DataLayout DL = cantFail(DataLayout::parse(Layout)); 488 EXPECT_EQ(DL.getPointerSize(0), V0) << Layout; 489 EXPECT_EQ(DL.getPointerSize(1), V1) << Layout; 490 EXPECT_EQ(DL.getPointerSize(2), V2) << Layout; 491 } 492 } 493 494 TEST(DataLayout, GetIndexSizeInBits) { 495 std::tuple<StringRef, unsigned, unsigned, unsigned> Cases[] = { 496 {"", 64, 64, 64}, 497 {"p:16:32", 16, 16, 16}, 498 {"p0:32:64", 32, 32, 32}, 499 {"p1:16:32:32:10", 64, 10, 64}, 500 {"p1:31:32:64:20-p2:17:16:16:15", 64, 20, 15}, 501 }; 502 for (auto [Layout, V0, V1, V2] : Cases) { 503 DataLayout DL = cantFail(DataLayout::parse(Layout)); 504 EXPECT_EQ(DL.getIndexSizeInBits(0), V0) << Layout; 505 EXPECT_EQ(DL.getIndexSizeInBits(1), V1) << Layout; 506 EXPECT_EQ(DL.getIndexSizeInBits(2), V2) << Layout; 507 } 508 } 509 510 TEST(DataLayout, GetIndexSize) { 511 std::tuple<StringRef, unsigned, unsigned, unsigned> Cases[] = { 512 {"", 8, 8, 8}, 513 {"p:16:32", 2, 2, 2}, 514 {"p0:27:64", 4, 4, 4}, 515 {"p1:19:32:64:5", 8, 1, 8}, 516 {"p1:33:32:64:23-p2:21:8:16:13", 8, 3, 2}, 517 }; 518 for (auto [Layout, V0, V1, V2] : Cases) { 519 DataLayout DL = cantFail(DataLayout::parse(Layout)); 520 EXPECT_EQ(DL.getIndexSize(0), V0) << Layout; 521 EXPECT_EQ(DL.getIndexSize(1), V1) << Layout; 522 EXPECT_EQ(DL.getIndexSize(2), V2) << Layout; 523 } 524 } 525 526 TEST(DataLayout, GetPointerABIAlignment) { 527 std::tuple<StringRef, unsigned, unsigned, unsigned> Cases[] = { 528 {"", 8, 8, 8}, 529 {"p:16:32", 4, 4, 4}, 530 {"p0:16:32:64", 4, 4, 4}, 531 {"p1:32:16:64", 8, 2, 8}, 532 {"p1:33:16:32:15-p2:23:8:16:9", 8, 2, 1}, 533 }; 534 for (auto [Layout, V0, V1, V2] : Cases) { 535 DataLayout DL = cantFail(DataLayout::parse(Layout)); 536 EXPECT_EQ(DL.getPointerABIAlignment(0).value(), V0) << Layout; 537 EXPECT_EQ(DL.getPointerABIAlignment(1).value(), V1) << Layout; 538 EXPECT_EQ(DL.getPointerABIAlignment(2).value(), V2) << Layout; 539 } 540 } 541 542 TEST(DataLayout, GetPointerPrefAlignment) { 543 std::tuple<StringRef, unsigned, unsigned, unsigned> Cases[] = { 544 {"", 8, 8, 8}, 545 {"p:16:32", 4, 4, 4}, 546 {"p0:8:16:32", 4, 4, 4}, 547 {"p1:32:8:16", 8, 2, 8}, 548 {"p1:33:8:16:31-p2:23:8:32:17", 8, 2, 4}, 549 }; 550 for (auto [Layout, V0, V1, V2] : Cases) { 551 DataLayout DL = cantFail(DataLayout::parse(Layout)); 552 EXPECT_EQ(DL.getPointerPrefAlignment(0).value(), V0) << Layout; 553 EXPECT_EQ(DL.getPointerPrefAlignment(1).value(), V1) << Layout; 554 EXPECT_EQ(DL.getPointerPrefAlignment(2).value(), V2) << Layout; 555 } 556 } 557 558 TEST(DataLayout, IsNonIntegralAddressSpace) { 559 DataLayout Default; 560 EXPECT_THAT(Default.getNonIntegralAddressSpaces(), ::testing::SizeIs(0)); 561 EXPECT_FALSE(Default.isNonIntegralAddressSpace(0)); 562 EXPECT_FALSE(Default.isNonIntegralAddressSpace(1)); 563 564 DataLayout Custom = cantFail(DataLayout::parse("ni:2:16777215")); 565 EXPECT_THAT(Custom.getNonIntegralAddressSpaces(), 566 ::testing::ElementsAreArray({2U, 16777215U})); 567 EXPECT_FALSE(Custom.isNonIntegralAddressSpace(0)); 568 EXPECT_FALSE(Custom.isNonIntegralAddressSpace(1)); 569 EXPECT_TRUE(Custom.isNonIntegralAddressSpace(2)); 570 EXPECT_TRUE(Custom.isNonIntegralAddressSpace(16777215)); 571 } 572 573 TEST(DataLayoutTest, CopyAssignmentInvalidatesStructLayout) { 574 DataLayout DL1 = cantFail(DataLayout::parse("p:32:32")); 575 DataLayout DL2 = cantFail(DataLayout::parse("p:64:64")); 576 577 LLVMContext Ctx; 578 StructType *Ty = StructType::get(PointerType::getUnqual(Ctx)); 579 580 // Initialize struct layout caches. 581 EXPECT_EQ(DL1.getStructLayout(Ty)->getSizeInBits(), 32U); 582 EXPECT_EQ(DL1.getStructLayout(Ty)->getAlignment(), Align(4)); 583 EXPECT_EQ(DL2.getStructLayout(Ty)->getSizeInBits(), 64U); 584 EXPECT_EQ(DL2.getStructLayout(Ty)->getAlignment(), Align(8)); 585 586 // The copy should invalidate DL1's cache. 587 DL1 = DL2; 588 EXPECT_EQ(DL1.getStructLayout(Ty)->getSizeInBits(), 64U); 589 EXPECT_EQ(DL1.getStructLayout(Ty)->getAlignment(), Align(8)); 590 EXPECT_EQ(DL2.getStructLayout(Ty)->getSizeInBits(), 64U); 591 EXPECT_EQ(DL2.getStructLayout(Ty)->getAlignment(), Align(8)); 592 } 593 594 TEST(DataLayoutTest, FunctionPtrAlign) { 595 EXPECT_EQ(MaybeAlign(0), DataLayout("").getFunctionPtrAlign()); 596 EXPECT_EQ(MaybeAlign(1), DataLayout("Fi8").getFunctionPtrAlign()); 597 EXPECT_EQ(MaybeAlign(2), DataLayout("Fi16").getFunctionPtrAlign()); 598 EXPECT_EQ(MaybeAlign(4), DataLayout("Fi32").getFunctionPtrAlign()); 599 EXPECT_EQ(MaybeAlign(8), DataLayout("Fi64").getFunctionPtrAlign()); 600 EXPECT_EQ(MaybeAlign(1), DataLayout("Fn8").getFunctionPtrAlign()); 601 EXPECT_EQ(MaybeAlign(2), DataLayout("Fn16").getFunctionPtrAlign()); 602 EXPECT_EQ(MaybeAlign(4), DataLayout("Fn32").getFunctionPtrAlign()); 603 EXPECT_EQ(MaybeAlign(8), DataLayout("Fn64").getFunctionPtrAlign()); 604 EXPECT_EQ(DataLayout::FunctionPtrAlignType::Independent, 605 DataLayout("").getFunctionPtrAlignType()); 606 EXPECT_EQ(DataLayout::FunctionPtrAlignType::Independent, 607 DataLayout("Fi8").getFunctionPtrAlignType()); 608 EXPECT_EQ(DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign, 609 DataLayout("Fn8").getFunctionPtrAlignType()); 610 EXPECT_EQ(DataLayout("Fi8"), DataLayout("Fi8")); 611 EXPECT_NE(DataLayout("Fi8"), DataLayout("Fi16")); 612 EXPECT_NE(DataLayout("Fi8"), DataLayout("Fn8")); 613 614 DataLayout a(""), b("Fi8"), c("Fn8"); 615 EXPECT_NE(a, b); 616 EXPECT_NE(a, c); 617 EXPECT_NE(b, c); 618 619 a = b; 620 EXPECT_EQ(a, b); 621 a = c; 622 EXPECT_EQ(a, c); 623 } 624 625 TEST(DataLayoutTest, ValueOrABITypeAlignment) { 626 const DataLayout DL("Fi8"); 627 LLVMContext Context; 628 Type *const FourByteAlignType = Type::getInt32Ty(Context); 629 EXPECT_EQ(Align(16), 630 DL.getValueOrABITypeAlignment(MaybeAlign(16), FourByteAlignType)); 631 EXPECT_EQ(Align(4), 632 DL.getValueOrABITypeAlignment(MaybeAlign(), FourByteAlignType)); 633 } 634 635 TEST(DataLayoutTest, GlobalsAddressSpace) { 636 // When not explicitly defined the globals address space should be zero: 637 EXPECT_EQ(DataLayout("").getDefaultGlobalsAddressSpace(), 0u); 638 EXPECT_EQ(DataLayout("P1-A2").getDefaultGlobalsAddressSpace(), 0u); 639 EXPECT_EQ(DataLayout("G2").getDefaultGlobalsAddressSpace(), 2u); 640 // Check that creating a GlobalVariable without an explicit address space 641 // in a module with a default globals address space respects that default: 642 LLVMContext Context; 643 std::unique_ptr<Module> M(new Module("MyModule", Context)); 644 // Default is globals in address space zero: 645 auto *Int32 = Type::getInt32Ty(Context); 646 auto *DefaultGlobal1 = new GlobalVariable( 647 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr); 648 EXPECT_EQ(DefaultGlobal1->getAddressSpace(), 0u); 649 auto *ExplicitGlobal1 = new GlobalVariable( 650 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr, "", nullptr, 651 GlobalValue::NotThreadLocal, 123); 652 EXPECT_EQ(ExplicitGlobal1->getAddressSpace(), 123u); 653 654 // When using a datalayout with the global address space set to 200, global 655 // variables should default to 200 656 M->setDataLayout("G200"); 657 auto *DefaultGlobal2 = new GlobalVariable( 658 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr); 659 EXPECT_EQ(DefaultGlobal2->getAddressSpace(), 200u); 660 auto *ExplicitGlobal2 = new GlobalVariable( 661 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr, "", nullptr, 662 GlobalValue::NotThreadLocal, 123); 663 EXPECT_EQ(ExplicitGlobal2->getAddressSpace(), 123u); 664 } 665 666 TEST(DataLayoutTest, VectorAlign) { 667 Expected<DataLayout> DL = DataLayout::parse("v64:64"); 668 EXPECT_THAT_EXPECTED(DL, Succeeded()); 669 670 LLVMContext Context; 671 Type *const FloatTy = Type::getFloatTy(Context); 672 Type *const V8F32Ty = FixedVectorType::get(FloatTy, 8); 673 674 // The alignment for a vector type larger than any specified vector type uses 675 // the natural alignment as a fallback. 676 EXPECT_EQ(Align(4 * 8), DL->getABITypeAlign(V8F32Ty)); 677 EXPECT_EQ(Align(4 * 8), DL->getPrefTypeAlign(V8F32Ty)); 678 } 679 680 TEST(DataLayoutTest, UEFI) { 681 Triple TT = Triple("x86_64-unknown-uefi"); 682 683 // Test UEFI X86_64 Mangling Component. 684 EXPECT_STREQ(DataLayout::getManglingComponent(TT), "-m:w"); 685 } 686 687 } // anonymous namespace 688