1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "register_test.h"
17
18 #include <bitset>
19
20 using namespace testing::ext;
21 using namespace std;
22 using namespace OHOS::HiviewDFX;
23 namespace OHOS {
24 namespace Developtools {
25 namespace HiPerf {
26 class RegisterTest : public testing::Test {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp();
31 void TearDown();
32 };
33
SetUpTestCase()34 void RegisterTest::SetUpTestCase() {}
35
TearDownTestCase()36 void RegisterTest::TearDownTestCase() {}
37
SetUp()38 void RegisterTest::SetUp() {}
39
TearDown()40 void RegisterTest::TearDown() {}
41
42 /**
43 * @tc.name: GetArchName
44 * @tc.desc:
45 * @tc.type: FUNC
46 */
47 HWTEST_F(RegisterTest, GetArchName, TestSize.Level1)
48 {
49 EXPECT_EQ(GetArchName(ArchType::X86_32).compare("X86_32"), 0);
50 EXPECT_EQ(GetArchName(ArchType::X86_64).compare("X86_64"), 0);
51 EXPECT_EQ(GetArchName(ArchType::ARM).compare("ARM"), 0);
52 EXPECT_EQ(GetArchName(ArchType::ARM64).compare("ARM64"), 0);
53 EXPECT_EQ(GetArchName(static_cast<ArchType>(100)).compare("Unsupport"), 0);
54 EXPECT_EQ(GetArchName(static_cast<ArchType>(-1)).compare("Unsupport"), 0);
55 }
56
57 /**
58 * @tc.name: GetSupportedRegMask
59 * @tc.desc:
60 * @tc.type: FUNC
61 */
62 HWTEST_F(RegisterTest, GetSupportedRegMask, TestSize.Level1)
63 {
64 EXPECT_NE(GetSupportedRegMask(ArchType::X86_32), GetSupportedRegMask(ArchType::X86_64));
65 EXPECT_NE(GetSupportedRegMask(ArchType::ARM), GetSupportedRegMask(ArchType::ARM64));
66 EXPECT_EQ(GetSupportedRegMask(static_cast<ArchType>(100)),
67 std::numeric_limits<uint64_t>::max());
68 EXPECT_EQ(GetSupportedRegMask(static_cast<ArchType>(-1)), std::numeric_limits<uint64_t>::max());
69
70 std::bitset<64> regMasker;
71 regMasker = GetSupportedRegMask(ArchType::X86_32);
72 EXPECT_EQ(regMasker.count(), PERF_REG_X86_32_MAX);
73
74 regMasker = GetSupportedRegMask(ArchType::X86_64);
75 // dont support PERF_REG_X86_DS,PERF_REG_X86_ES,PERF_REG_X86_FS,PERF_REG_X86_GS
76 EXPECT_EQ(regMasker.count(), PERF_REG_X86_64_MAX - 4u);
77
78 regMasker = GetSupportedRegMask(ArchType::ARM);
79 EXPECT_EQ(regMasker.count(), PERF_REG_ARM_MAX);
80
81 regMasker = GetSupportedRegMask(ArchType::ARM64);
82 EXPECT_EQ(regMasker.count(), PERF_REG_ARM64_MAX);
83 }
84
85 /**
86 * @tc.name: RegisterGetIP
87 * @tc.desc:
88 * @tc.type: FUNC
89 */
90 HWTEST_F(RegisterTest, RegisterGetIP, TestSize.Level1)
91 {
92 #if defined(target_cpu_x86_64)
93 EXPECT_EQ(RegisterGetIP(ArchType::X86_64), PERF_REG_X86_IP);
94 #elif defined(target_cpu_arm)
95 EXPECT_EQ(RegisterGetIP(ArchType::ARM), PERF_REG_ARM_PC);
96 #elif defined(target_cpu_arm64)
97 EXPECT_EQ(RegisterGetIP(ArchType::ARM64), PERF_REG_ARM64_PC);
98 #endif
99 }
100
101 /**
102 * @tc.name: RegisterGetSP
103 * @tc.desc:
104 * @tc.type: FUNC
105 */
106 HWTEST_F(RegisterTest, RegisterGetSP, TestSize.Level1)
107 {
108 #if defined(target_cpu_x86_64)
109 EXPECT_EQ(RegisterGetSP(ArchType::X86_64), PERF_REG_X86_IP);
110 #elif defined(target_cpu_arm)
111 EXPECT_EQ(RegisterGetSP(ArchType::ARM), PERF_REG_ARM_SP);
112 #elif defined(target_cpu_arm64)
113 EXPECT_EQ(RegisterGetSP(ArchType::ARM64), PERF_REG_ARM64_SP);
114 #endif
115 }
116
117 /**
118 * @tc.name: RegisterGetValue
119 * @tc.desc:
120 * @tc.type: FUNC
121 */
122 HWTEST_F(RegisterTest, RegisterGetValue, TestSize.Level1)
123 {
124 uint64_t value = 0;
125 const u64 registers[4] = {1, 2, 3, 4};
126 size_t registerIndex = 0;
127
128 EXPECT_EQ(RegisterGetValue(value, registers, 0, sizeof(registers)), true);
129 EXPECT_EQ(RegisterGetValue(value, registers, sizeof(registers), sizeof(registers)), false);
130 EXPECT_EQ(RegisterGetValue(value, registers, -1, sizeof(registers)), false);
131
132 for (unsigned i = 0; i < sizeof(registers); i++) {
133 RegisterGetValue(value, registers, i, sizeof(registers));
134 EXPECT_EQ(value, registers[i]);
135 }
136 }
137
138 /**
139 * @tc.name: RegisterGetSPValue
140 * @tc.desc:
141 * @tc.type: FUNC
142 */
143 HWTEST_F(RegisterTest, RegisterGetSPValue, TestSize.Level1)
144 {
145 uint64_t value = 0;
146 uint64_t value2 = 0;
147 u64 registers[PERF_REG_ARM64_MAX] = {1, 2, 3, 4};
148 size_t registerIndex = 0;
149 size_t sp = RegisterGetSP(buildArchType);
150 registers[sp] = 0x1234;
151
152 EXPECT_EQ(RegisterGetValue(value, registers, sp, sizeof(registers)),
153 RegisterGetSPValue(value2, buildArchType, registers, sizeof(registers)));
154
155 EXPECT_EQ(value, value2);
156 }
157
158 /**
159 * @tc.name: RegisterGetIPValue
160 * @tc.desc:
161 * @tc.type: FUNC
162 */
163 HWTEST_F(RegisterTest, RegisterGetIPValue, TestSize.Level1)
164 {
165 uint64_t value = 0;
166 uint64_t value2 = 0;
167 u64 registers[PERF_REG_ARM64_MAX] = {1, 2, 3, 4};
168 size_t registerIndex = 0;
169 size_t ip = RegisterGetIP(buildArchType);
170 registers[ip] = 0x1234;
171
172 EXPECT_EQ(RegisterGetValue(value, registers, ip, sizeof(registers)),
173 RegisterGetIPValue(value2, buildArchType, registers, sizeof(registers)));
174
175 EXPECT_EQ(value, value2);
176 }
177
178 /**
179 * @tc.name: RegisterGetName
180 * @tc.desc:
181 * @tc.type: FUNC
182 */
183 HWTEST_F(RegisterTest, RegisterGetName, TestSize.Level1)
184 {
185 for (unsigned i = 0; i < PERF_REG_ARM64_MAX; i++) {
186 EXPECT_EQ(RegisterGetName(i).empty(), false);
187 }
188 }
189
190 /**
191 * @tc.name: LibunwindRegIdToPerfReg
192 * @tc.desc:
193 * @tc.type: FUNC
194 */
195 HWTEST_F(RegisterTest, LibunwindRegIdToPerfReg, TestSize.Level1)
196 {
197 #if defined(target_cpu_x86_64)
198 unsigned max = PERF_REG_X86_64_MAX;
199 #elif defined(target_cpu_arm)
200 unsigned max = PERF_REG_ARM_MAX;
201 #elif defined(target_cpu_arm64)
202 unsigned max = PERF_REG_ARM64_MAX;
203 #endif
204 for (unsigned i = 0; i < max; i++) {
205 EXPECT_EQ(LibunwindRegIdToPerfReg(i) >= 0, true);
206 }
207 EXPECT_EQ(LibunwindRegIdToPerfReg(max + 1) < 0, true);
208 EXPECT_EQ(LibunwindRegIdToPerfReg(-1) < 0, true);
209 }
210 } // namespace HiPerf
211 } // namespace Developtools
212 } // namespace OHOS
213