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