1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
//===- SFrameTest.cpp -----------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/BinaryFormat/SFrame.h"
#include "gtest/gtest.h"
#include <type_traits>
using namespace llvm;
using namespace llvm::sframe;
namespace {
template <typename EndianT> class SFrameTest : public testing::Test {
protected:
static constexpr endianness Endian = EndianT::value;
// Test structure sizes and triviality.
static_assert(std::is_trivial_v<Preamble<Endian>>);
static_assert(sizeof(Preamble<Endian>) == 4);
static_assert(std::is_trivial_v<Header<Endian>>);
static_assert(sizeof(Header<Endian>) == 28);
static_assert(std::is_trivial_v<FuncDescEntry<Endian>>);
static_assert(sizeof(FuncDescEntry<Endian>) == 20);
static_assert(std::is_trivial_v<FrameRowEntryAddr1<Endian>>);
static_assert(sizeof(FrameRowEntryAddr1<Endian>) == 2);
static_assert(std::is_trivial_v<FrameRowEntryAddr2<Endian>>);
static_assert(sizeof(FrameRowEntryAddr2<Endian>) == 3);
static_assert(std::is_trivial_v<FrameRowEntryAddr4<Endian>>);
static_assert(sizeof(FrameRowEntryAddr4<Endian>) == 5);
};
struct NameGenerator {
template <typename T> static constexpr const char *GetName(int) {
if constexpr (T::value == endianness::little)
return "little";
if constexpr (T::value == endianness::big)
return "big";
}
};
using Types =
testing::Types<std::integral_constant<endianness, endianness::little>,
std::integral_constant<endianness, endianness::big>>;
TYPED_TEST_SUITE(SFrameTest, Types, NameGenerator);
TYPED_TEST(SFrameTest, FDEFlags) {
FuncDescEntry<TestFixture::Endian> FDE = {};
EXPECT_EQ(FDE.Info, 0u);
EXPECT_EQ(FDE.getPAuthKey(), 0);
EXPECT_EQ(FDE.getFDEType(), FDEType::PCInc);
EXPECT_EQ(FDE.getFREType(), FREType::Addr1);
FDE.setPAuthKey(1);
EXPECT_EQ(FDE.Info, 0x20u);
EXPECT_EQ(FDE.getPAuthKey(), 1);
EXPECT_EQ(FDE.getFDEType(), FDEType::PCInc);
EXPECT_EQ(FDE.getFREType(), FREType::Addr1);
FDE.setFDEType(FDEType::PCMask);
EXPECT_EQ(FDE.Info, 0x30u);
EXPECT_EQ(FDE.getPAuthKey(), 1);
EXPECT_EQ(FDE.getFDEType(), FDEType::PCMask);
EXPECT_EQ(FDE.getFREType(), FREType::Addr1);
FDE.setFREType(FREType::Addr4);
EXPECT_EQ(FDE.Info, 0x32u);
EXPECT_EQ(FDE.getPAuthKey(), 1);
EXPECT_EQ(FDE.getFDEType(), FDEType::PCMask);
EXPECT_EQ(FDE.getFREType(), FREType::Addr4);
}
TYPED_TEST(SFrameTest, FREFlags) {
FREInfo<TestFixture::Endian> Info = {};
EXPECT_EQ(Info.Info, 0u);
EXPECT_FALSE(Info.isReturnAddressSigned());
EXPECT_EQ(Info.getOffsetSize(), FREOffset::B1);
EXPECT_EQ(Info.getOffsetCount(), 0u);
EXPECT_EQ(Info.getBaseRegister(), BaseReg::FP);
Info.setReturnAddressSigned(true);
EXPECT_EQ(Info.Info, 0x80u);
EXPECT_TRUE(Info.isReturnAddressSigned());
EXPECT_EQ(Info.getOffsetSize(), FREOffset::B1);
EXPECT_EQ(Info.getOffsetCount(), 0u);
EXPECT_EQ(Info.getBaseRegister(), BaseReg::FP);
Info.setOffsetSize(FREOffset::B4);
EXPECT_EQ(Info.Info, 0xc0u);
EXPECT_TRUE(Info.isReturnAddressSigned());
EXPECT_EQ(Info.getOffsetSize(), FREOffset::B4);
EXPECT_EQ(Info.getOffsetCount(), 0u);
EXPECT_EQ(Info.getBaseRegister(), BaseReg::FP);
Info.setOffsetCount(3);
EXPECT_EQ(Info.Info, 0xc6u);
EXPECT_TRUE(Info.isReturnAddressSigned());
EXPECT_EQ(Info.getOffsetSize(), FREOffset::B4);
EXPECT_EQ(Info.getOffsetCount(), 3u);
EXPECT_EQ(Info.getBaseRegister(), BaseReg::FP);
Info.setBaseRegister(BaseReg::SP);
EXPECT_EQ(Info.Info, 0xc7u);
EXPECT_TRUE(Info.isReturnAddressSigned());
EXPECT_EQ(Info.getOffsetSize(), FREOffset::B4);
EXPECT_EQ(Info.getOffsetCount(), 3u);
EXPECT_EQ(Info.getBaseRegister(), BaseReg::SP);
}
} // namespace
|
