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 // TODO: Split into multiple TESTs. 23 TEST(DataLayoutTest, ParseErrors) { 24 EXPECT_THAT_EXPECTED( 25 DataLayout::parse("^"), 26 FailedWithMessage("Unknown specifier in datalayout string")); 27 EXPECT_THAT_EXPECTED( 28 DataLayout::parse("m:v"), 29 FailedWithMessage("Unknown mangling in datalayout string")); 30 EXPECT_THAT_EXPECTED( 31 DataLayout::parse("n0"), 32 FailedWithMessage("Zero width native integer type in datalayout string")); 33 EXPECT_THAT_EXPECTED( 34 DataLayout::parse("p16777216:64:64:64"), 35 FailedWithMessage("Invalid address space, must be a 24-bit integer")); 36 EXPECT_THAT_EXPECTED( 37 DataLayout::parse("a1:64"), 38 FailedWithMessage("Sized aggregate specification in datalayout string")); 39 EXPECT_THAT_EXPECTED( 40 DataLayout::parse("a:"), 41 FailedWithMessage("Trailing separator in datalayout string")); 42 EXPECT_THAT_EXPECTED( 43 DataLayout::parse("p:48:52"), 44 FailedWithMessage("number of bits must be a byte width multiple")); 45 EXPECT_THAT_EXPECTED( 46 DataLayout::parse("e-p"), 47 FailedWithMessage( 48 "Missing size specification for pointer in datalayout string")); 49 EXPECT_THAT_EXPECTED( 50 DataLayout::parse("e-p:64"), 51 FailedWithMessage( 52 "Missing alignment specification for pointer in datalayout string")); 53 EXPECT_THAT_EXPECTED( 54 DataLayout::parse("m"), 55 FailedWithMessage("Expected mangling specifier in datalayout string")); 56 EXPECT_THAT_EXPECTED( 57 DataLayout::parse("m."), 58 FailedWithMessage("Unexpected trailing characters after mangling " 59 "specifier in datalayout string")); 60 EXPECT_THAT_EXPECTED( 61 DataLayout::parse("f"), 62 FailedWithMessage( 63 "Missing alignment specification in datalayout string")); 64 EXPECT_THAT_EXPECTED( 65 DataLayout::parse(":32"), 66 FailedWithMessage( 67 "Expected token before separator in datalayout string")); 68 EXPECT_THAT_EXPECTED( 69 DataLayout::parse("i64:64:16"), 70 FailedWithMessage( 71 "Preferred alignment cannot be less than the ABI alignment")); 72 EXPECT_THAT_EXPECTED( 73 DataLayout::parse("i64:16:16777216"), 74 FailedWithMessage( 75 "Invalid preferred alignment, must be a 16bit integer")); 76 EXPECT_THAT_EXPECTED( 77 DataLayout::parse("i64:16777216:16777216"), 78 FailedWithMessage("Invalid ABI alignment, must be a 16bit integer")); 79 EXPECT_THAT_EXPECTED( 80 DataLayout::parse("i16777216:16:16"), 81 FailedWithMessage("Invalid bit width, must be a 24-bit integer")); 82 EXPECT_THAT_EXPECTED( 83 DataLayout::parse("p:32:32:16"), 84 FailedWithMessage( 85 "Preferred alignment cannot be less than the ABI alignment")); 86 EXPECT_THAT_EXPECTED(DataLayout::parse("p:0:32:32"), 87 FailedWithMessage("Invalid pointer size of 0 bytes")); 88 EXPECT_THAT_EXPECTED( 89 DataLayout::parse("p:64:24:64"), 90 FailedWithMessage("Pointer ABI alignment must be a power of 2")); 91 EXPECT_THAT_EXPECTED( 92 DataLayout::parse("p:64:64:24"), 93 FailedWithMessage("Pointer preferred alignment must be a power of 2")); 94 EXPECT_THAT_EXPECTED( 95 DataLayout::parse("p:64:64:64:128"), 96 FailedWithMessage("Index width cannot be larger than pointer width")); 97 EXPECT_THAT_EXPECTED( 98 DataLayout::parse("v128:0:128"), 99 FailedWithMessage( 100 "ABI alignment specification must be >0 for non-aggregate types")); 101 EXPECT_THAT_EXPECTED( 102 DataLayout::parse("i32:24:32"), 103 FailedWithMessage("Invalid ABI alignment, must be a power of 2")); 104 EXPECT_THAT_EXPECTED( 105 DataLayout::parse("i32:32:24"), 106 FailedWithMessage("Invalid preferred alignment, must be a power of 2")); 107 EXPECT_THAT_EXPECTED( 108 DataLayout::parse("A16777216"), 109 FailedWithMessage("Invalid address space, must be a 24-bit integer")); 110 EXPECT_THAT_EXPECTED( 111 DataLayout::parse("G16777216"), 112 FailedWithMessage("Invalid address space, must be a 24-bit integer")); 113 EXPECT_THAT_EXPECTED( 114 DataLayout::parse("P16777216"), 115 FailedWithMessage("Invalid address space, must be a 24-bit integer")); 116 EXPECT_THAT_EXPECTED( 117 DataLayout::parse("Fi24"), 118 FailedWithMessage("Alignment is neither 0 nor a power of 2")); 119 EXPECT_THAT_EXPECTED( 120 DataLayout::parse("i8:16"), 121 FailedWithMessage("Invalid ABI alignment, i8 must be naturally aligned")); 122 EXPECT_THAT_EXPECTED( 123 DataLayout::parse("S24"), 124 FailedWithMessage("Alignment is neither 0 nor a power of 2")); 125 } 126 127 TEST(DataLayout, LayoutStringFormat) { 128 for (StringRef Str : {"", "e", "m:e", "m:e-e"}) 129 EXPECT_THAT_EXPECTED(DataLayout::parse(Str), Succeeded()); 130 131 for (StringRef Str : {"-", "e-", "-m:e", "m:e--e"}) 132 EXPECT_THAT_EXPECTED( 133 DataLayout::parse(Str), 134 FailedWithMessage("empty specification is not allowed")); 135 } 136 137 TEST(DataLayoutTest, CopyAssignmentInvalidatesStructLayout) { 138 DataLayout DL1 = cantFail(DataLayout::parse("p:32:32")); 139 DataLayout DL2 = cantFail(DataLayout::parse("p:64:64")); 140 141 LLVMContext Ctx; 142 StructType *Ty = StructType::get(PointerType::getUnqual(Ctx)); 143 144 // Initialize struct layout caches. 145 EXPECT_EQ(DL1.getStructLayout(Ty)->getSizeInBits(), 32U); 146 EXPECT_EQ(DL1.getStructLayout(Ty)->getAlignment(), Align(4)); 147 EXPECT_EQ(DL2.getStructLayout(Ty)->getSizeInBits(), 64U); 148 EXPECT_EQ(DL2.getStructLayout(Ty)->getAlignment(), Align(8)); 149 150 // The copy should invalidate DL1's cache. 151 DL1 = DL2; 152 EXPECT_EQ(DL1.getStructLayout(Ty)->getSizeInBits(), 64U); 153 EXPECT_EQ(DL1.getStructLayout(Ty)->getAlignment(), Align(8)); 154 EXPECT_EQ(DL2.getStructLayout(Ty)->getSizeInBits(), 64U); 155 EXPECT_EQ(DL2.getStructLayout(Ty)->getAlignment(), Align(8)); 156 } 157 158 TEST(DataLayoutTest, FunctionPtrAlign) { 159 EXPECT_EQ(MaybeAlign(0), DataLayout("").getFunctionPtrAlign()); 160 EXPECT_EQ(MaybeAlign(1), DataLayout("Fi8").getFunctionPtrAlign()); 161 EXPECT_EQ(MaybeAlign(2), DataLayout("Fi16").getFunctionPtrAlign()); 162 EXPECT_EQ(MaybeAlign(4), DataLayout("Fi32").getFunctionPtrAlign()); 163 EXPECT_EQ(MaybeAlign(8), DataLayout("Fi64").getFunctionPtrAlign()); 164 EXPECT_EQ(MaybeAlign(1), DataLayout("Fn8").getFunctionPtrAlign()); 165 EXPECT_EQ(MaybeAlign(2), DataLayout("Fn16").getFunctionPtrAlign()); 166 EXPECT_EQ(MaybeAlign(4), DataLayout("Fn32").getFunctionPtrAlign()); 167 EXPECT_EQ(MaybeAlign(8), DataLayout("Fn64").getFunctionPtrAlign()); 168 EXPECT_EQ(DataLayout::FunctionPtrAlignType::Independent, \ 169 DataLayout("").getFunctionPtrAlignType()); 170 EXPECT_EQ(DataLayout::FunctionPtrAlignType::Independent, \ 171 DataLayout("Fi8").getFunctionPtrAlignType()); 172 EXPECT_EQ(DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign, \ 173 DataLayout("Fn8").getFunctionPtrAlignType()); 174 EXPECT_EQ(DataLayout("Fi8"), DataLayout("Fi8")); 175 EXPECT_NE(DataLayout("Fi8"), DataLayout("Fi16")); 176 EXPECT_NE(DataLayout("Fi8"), DataLayout("Fn8")); 177 178 DataLayout a(""), b("Fi8"), c("Fn8"); 179 EXPECT_NE(a, b); 180 EXPECT_NE(a, c); 181 EXPECT_NE(b, c); 182 183 a = b; 184 EXPECT_EQ(a, b); 185 a = c; 186 EXPECT_EQ(a, c); 187 } 188 189 TEST(DataLayoutTest, ValueOrABITypeAlignment) { 190 const DataLayout DL("Fi8"); 191 LLVMContext Context; 192 Type *const FourByteAlignType = Type::getInt32Ty(Context); 193 EXPECT_EQ(Align(16), 194 DL.getValueOrABITypeAlignment(MaybeAlign(16), FourByteAlignType)); 195 EXPECT_EQ(Align(4), 196 DL.getValueOrABITypeAlignment(MaybeAlign(), FourByteAlignType)); 197 } 198 199 TEST(DataLayoutTest, GlobalsAddressSpace) { 200 // When not explicitly defined the globals address space should be zero: 201 EXPECT_EQ(DataLayout("").getDefaultGlobalsAddressSpace(), 0u); 202 EXPECT_EQ(DataLayout("P1-A2").getDefaultGlobalsAddressSpace(), 0u); 203 EXPECT_EQ(DataLayout("G2").getDefaultGlobalsAddressSpace(), 2u); 204 // Check that creating a GlobalVariable without an explicit address space 205 // in a module with a default globals address space respects that default: 206 LLVMContext Context; 207 std::unique_ptr<Module> M(new Module("MyModule", Context)); 208 // Default is globals in address space zero: 209 auto *Int32 = Type::getInt32Ty(Context); 210 auto *DefaultGlobal1 = new GlobalVariable( 211 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr); 212 EXPECT_EQ(DefaultGlobal1->getAddressSpace(), 0u); 213 auto *ExplicitGlobal1 = new GlobalVariable( 214 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr, "", nullptr, 215 GlobalValue::NotThreadLocal, 123); 216 EXPECT_EQ(ExplicitGlobal1->getAddressSpace(), 123u); 217 218 // When using a datalayout with the global address space set to 200, global 219 // variables should default to 200 220 M->setDataLayout("G200"); 221 auto *DefaultGlobal2 = new GlobalVariable( 222 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr); 223 EXPECT_EQ(DefaultGlobal2->getAddressSpace(), 200u); 224 auto *ExplicitGlobal2 = new GlobalVariable( 225 *M, Int32, false, GlobalValue::ExternalLinkage, nullptr, "", nullptr, 226 GlobalValue::NotThreadLocal, 123); 227 EXPECT_EQ(ExplicitGlobal2->getAddressSpace(), 123u); 228 } 229 230 TEST(DataLayoutTest, VectorAlign) { 231 Expected<DataLayout> DL = DataLayout::parse("v64:64"); 232 EXPECT_THAT_EXPECTED(DL, Succeeded()); 233 234 LLVMContext Context; 235 Type *const FloatTy = Type::getFloatTy(Context); 236 Type *const V8F32Ty = FixedVectorType::get(FloatTy, 8); 237 238 // The alignment for a vector type larger than any specified vector type uses 239 // the natural alignment as a fallback. 240 EXPECT_EQ(Align(4 * 8), DL->getABITypeAlign(V8F32Ty)); 241 EXPECT_EQ(Align(4 * 8), DL->getPrefTypeAlign(V8F32Ty)); 242 } 243 244 TEST(DataLayoutTest, UEFI) { 245 Triple TT = Triple("x86_64-unknown-uefi"); 246 247 // Test UEFI X86_64 Mangling Component. 248 EXPECT_STREQ(DataLayout::getManglingComponent(TT), "-m:w"); 249 } 250 251 } // anonymous namespace 252