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 TEST(DataLayoutTest, CopyAssignmentInvalidatesStructLayout) { 23 DataLayout DL1 = cantFail(DataLayout::parse("p:32:32")); 24 DataLayout DL2 = cantFail(DataLayout::parse("p:64:64")); 25 26 LLVMContext Ctx; 27 StructType *Ty = StructType::get(PointerType::getUnqual(Ctx)); 28 29 // Initialize struct layout caches. 30 EXPECT_EQ(DL1.getStructLayout(Ty)->getSizeInBits(), 32U); 31 EXPECT_EQ(DL1.getStructLayout(Ty)->getAlignment(), Align(4)); 32 EXPECT_EQ(DL2.getStructLayout(Ty)->getSizeInBits(), 64U); 33 EXPECT_EQ(DL2.getStructLayout(Ty)->getAlignment(), Align(8)); 34 35 // The copy should invalidate DL1's cache. 36 DL1 = DL2; 37 EXPECT_EQ(DL1.getStructLayout(Ty)->getSizeInBits(), 64U); 38 EXPECT_EQ(DL1.getStructLayout(Ty)->getAlignment(), Align(8)); 39 EXPECT_EQ(DL2.getStructLayout(Ty)->getSizeInBits(), 64U); 40 EXPECT_EQ(DL2.getStructLayout(Ty)->getAlignment(), Align(8)); 41 } 42 43 TEST(DataLayoutTest, FunctionPtrAlign) { 44 EXPECT_EQ(MaybeAlign(0), DataLayout("").getFunctionPtrAlign()); 45 EXPECT_EQ(MaybeAlign(1), DataLayout("Fi8").getFunctionPtrAlign()); 46 EXPECT_EQ(MaybeAlign(2), DataLayout("Fi16").getFunctionPtrAlign()); 47 EXPECT_EQ(MaybeAlign(4), DataLayout("Fi32").getFunctionPtrAlign()); 48 EXPECT_EQ(MaybeAlign(8), DataLayout("Fi64").getFunctionPtrAlign()); 49 EXPECT_EQ(MaybeAlign(1), DataLayout("Fn8").getFunctionPtrAlign()); 50 EXPECT_EQ(MaybeAlign(2), DataLayout("Fn16").getFunctionPtrAlign()); 51 EXPECT_EQ(MaybeAlign(4), DataLayout("Fn32").getFunctionPtrAlign()); 52 EXPECT_EQ(MaybeAlign(8), DataLayout("Fn64").getFunctionPtrAlign()); 53 EXPECT_EQ(DataLayout::FunctionPtrAlignType::Independent, \ 54 DataLayout("").getFunctionPtrAlignType()); 55 EXPECT_EQ(DataLayout::FunctionPtrAlignType::Independent, \ 56 DataLayout("Fi8").getFunctionPtrAlignType()); 57 EXPECT_EQ(DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign, \ 58 DataLayout("Fn8").getFunctionPtrAlignType()); 59 EXPECT_EQ(DataLayout("Fi8"), DataLayout("Fi8")); 60 EXPECT_NE(DataLayout("Fi8"), DataLayout("Fi16")); 61 EXPECT_NE(DataLayout("Fi8"), DataLayout("Fn8")); 62 63 DataLayout a(""), b("Fi8"), c("Fn8"); 64 EXPECT_NE(a, b); 65 EXPECT_NE(a, c); 66 EXPECT_NE(b, c); 67 68 a = b; 69 EXPECT_EQ(a, b); 70 a = c; 71 EXPECT_EQ(a, c); 72 } 73 74 TEST(DataLayoutTest, ValueOrABITypeAlignment) { 75 const DataLayout DL("Fi8"); 76 LLVMContext Context; 77 Type *const FourByteAlignType = Type::getInt32Ty(Context); 78 EXPECT_EQ(Align(16), 79 DL.getValueOrABITypeAlignment(MaybeAlign(16), FourByteAlignType)); 80 EXPECT_EQ(Align(4), 81 DL.getValueOrABITypeAlignment(MaybeAlign(), FourByteAlignType)); 82 } 83 84 TEST(DataLayoutTest, GlobalsAddressSpace) { 85 // When not explicitly defined the globals address space should be zero: 86 EXPECT_EQ(DataLayout("").getDefaultGlobalsAddressSpace(), 0u); 87 EXPECT_EQ(DataLayout("P1-A2").getDefaultGlobalsAddressSpace(), 0u); 88 EXPECT_EQ(DataLayout("G2").getDefaultGlobalsAddressSpace(), 2u); 89 // Check that creating a GlobalVariable without an explicit address space 90 // in a module with a default globals address space respects that default: 91 LLVMContext Context; 92 std::unique_ptr<Module> M(new Module("MyModule", Context)); 93 // Default is globals in address space zero: 94 auto *Int32 = Type::getInt32Ty(Context); 95 auto *DefaultGlobal1 = new GlobalVariable( 96 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr); 97 EXPECT_EQ(DefaultGlobal1->getAddressSpace(), 0u); 98 auto *ExplicitGlobal1 = new GlobalVariable( 99 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr, "", nullptr, 100 GlobalValue::NotThreadLocal, 123); 101 EXPECT_EQ(ExplicitGlobal1->getAddressSpace(), 123u); 102 103 // When using a datalayout with the global address space set to 200, global 104 // variables should default to 200 105 M->setDataLayout("G200"); 106 auto *DefaultGlobal2 = new GlobalVariable( 107 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr); 108 EXPECT_EQ(DefaultGlobal2->getAddressSpace(), 200u); 109 auto *ExplicitGlobal2 = new GlobalVariable( 110 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr, "", nullptr, 111 GlobalValue::NotThreadLocal, 123); 112 EXPECT_EQ(ExplicitGlobal2->getAddressSpace(), 123u); 113 } 114 115 TEST(DataLayoutTest, VectorAlign) { 116 Expected<DataLayout> DL = DataLayout::parse("v64:64"); 117 EXPECT_THAT_EXPECTED(DL, Succeeded()); 118 119 LLVMContext Context; 120 Type *const FloatTy = Type::getFloatTy(Context); 121 Type *const V8F32Ty = FixedVectorType::get(FloatTy, 8); 122 123 // The alignment for a vector type larger than any specified vector type uses 124 // the natural alignment as a fallback. 125 EXPECT_EQ(Align(4 * 8), DL->getABITypeAlign(V8F32Ty)); 126 EXPECT_EQ(Align(4 * 8), DL->getPrefTypeAlign(V8F32Ty)); 127 } 128 129 TEST(DataLayoutTest, UEFI) { 130 Triple TT = Triple("x86_64-unknown-uefi"); 131 132 // Test UEFI X86_64 Mangling Component. 133 EXPECT_STREQ(DataLayout::getManglingComponent(TT), "-m:w"); 134 } 135 136 } // anonymous namespace 137