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