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 #define UNW_EMPTY_STRUCT uint8_t unused;
16
17 #include "register_test.h"
18
19 #include <bitset>
20
21 #if HAVE_LIBUNWIND
22 #include "libunwind.h"
23 #endif
24
25 using namespace testing::ext;
26 using namespace std;
27 #ifndef CONFIG_NO_HILOG
28 using namespace OHOS::HiviewDFX;
29 #endif
30 namespace OHOS {
31 namespace Developtools {
32 namespace NativeDaemon {
33 class RegisterTest : public testing::Test {
34 public:
35 static void SetUpTestCase(void);
36 static void TearDownTestCase(void);
37 void SetUp();
38 void TearDown();
39 };
40
SetUpTestCase()41 void RegisterTest::SetUpTestCase() {}
42
TearDownTestCase()43 void RegisterTest::TearDownTestCase() {}
44
SetUp()45 void RegisterTest::SetUp() {}
46
TearDown()47 void RegisterTest::TearDown() {}
48
49 /**
50 * @tc.name: GetArchName
51 * @tc.desc:
52 * @tc.type: FUNC
53 */
54 HWTEST_F(RegisterTest, GetArchName, TestSize.Level1)
55 {
56 EXPECT_EQ(GetArchName(ArchType::X86_32).compare("X86_32"), 0);
57 EXPECT_EQ(GetArchName(ArchType::X86_64).compare("X86_64"), 0);
58 EXPECT_EQ(GetArchName(ArchType::ARM).compare("ARM"), 0);
59 EXPECT_EQ(GetArchName(ArchType::ARM64).compare("ARM64"), 0);
60 EXPECT_EQ(GetArchName(static_cast<ArchType>(100)).compare("Unsupport"), 0);
61 EXPECT_EQ(GetArchName(static_cast<ArchType>(-1)).compare("Unsupport"), 0);
62 }
63
64 /**
65 * @tc.name: GetSupportedRegMask
66 * @tc.desc:
67 * @tc.type: FUNC
68 */
69 HWTEST_F(RegisterTest, GetSupportedRegMask, TestSize.Level1)
70 {
71 EXPECT_NE(GetSupportedRegMask(ArchType::X86_32), GetSupportedRegMask(ArchType::X86_64));
72 EXPECT_NE(GetSupportedRegMask(ArchType::ARM), GetSupportedRegMask(ArchType::ARM64));
73 EXPECT_EQ(GetSupportedRegMask(static_cast<ArchType>(100)),
74 std::numeric_limits<uint64_t>::max());
75 EXPECT_EQ(GetSupportedRegMask(static_cast<ArchType>(-1)), std::numeric_limits<uint64_t>::max());
76
77 std::bitset<64> regMasker;
78 regMasker = GetSupportedRegMask(ArchType::X86_32);
79 EXPECT_EQ(regMasker.count(), PERF_REG_X86_32_MAX);
80
81 regMasker = GetSupportedRegMask(ArchType::X86_64);
82 // dont support PERF_REG_X86_DS,PERF_REG_X86_ES,PERF_REG_X86_FS,PERF_REG_X86_GS
83 EXPECT_EQ(regMasker.count(), PERF_REG_X86_64_MAX - 4u);
84
85 regMasker = GetSupportedRegMask(ArchType::ARM);
86 EXPECT_EQ(regMasker.count(), PERF_REG_ARM_MAX);
87
88 regMasker = GetSupportedRegMask(ArchType::ARM64);
89 EXPECT_EQ(regMasker.count(), PERF_REG_ARM64_MAX);
90 }
91
92 /**
93 * @tc.name: RegisterGetIP
94 * @tc.desc:
95 * @tc.type: FUNC
96 */
97 HWTEST_F(RegisterTest, RegisterGetIP, TestSize.Level1)
98 {
99 #if defined(target_cpu_x64)
100 EXPECT_EQ(RegisterGetIP(), PERF_REG_X86_IP);
101 #elif defined(target_cpu_arm)
102 EXPECT_EQ(RegisterGetIP(), PERF_REG_ARM_PC);
103 #elif defined(target_cpu_arm64)
104 EXPECT_EQ(RegisterGetIP(), PERF_REG_ARM64_PC);
105 #endif
106 }
107
108 /**
109 * @tc.name: RegisterGetSP
110 * @tc.desc:
111 * @tc.type: FUNC
112 */
113 HWTEST_F(RegisterTest, RegisterGetSP, TestSize.Level1)
114 {
115 #if defined(target_cpu_x64)
116 EXPECT_EQ(RegisterGetSP(), PERF_REG_X86_IP);
117 #elif defined(target_cpu_arm)
118 EXPECT_EQ(RegisterGetSP(), PERF_REG_ARM_SP);
119 #elif defined(target_cpu_arm64)
120 EXPECT_EQ(RegisterGetSP(), PERF_REG_ARM64_SP);
121 #endif
122 }
123
124 /**
125 * @tc.name: RegisterGetValue
126 * @tc.desc:
127 * @tc.type: FUNC
128 */
129 HWTEST_F(RegisterTest, RegisterGetValue, TestSize.Level1)
130 {
131 uint64_t value = 0;
132 const u64 registers[4] = {1, 2, 3, 4};
133 size_t registerIndex = 0;
134
135 EXPECT_EQ(RegisterGetValue(value, registers, 0, sizeof(registers)), true);
136 EXPECT_EQ(RegisterGetValue(value, registers, sizeof(registers), sizeof(registers)), false);
137 EXPECT_EQ(RegisterGetValue(value, registers, -1, sizeof(registers)), false);
138
139 for (unsigned i = 0; i < sizeof(registers); i++) {
140 RegisterGetValue(value, registers, i, sizeof(registers));
141 EXPECT_EQ(value, registers[i]);
142 }
143 }
144
145 /**
146 * @tc.name: RegisterGetSPValue
147 * @tc.desc:
148 * @tc.type: FUNC
149 */
150 HWTEST_F(RegisterTest, RegisterGetSPValue, TestSize.Level1)
151 {
152 uint64_t value = 0;
153 uint64_t value2 = 0;
154 u64 registers[PERF_REG_ARM64_MAX] = {1, 2, 3, 4};
155 size_t registerIndex = 0;
156 size_t sp = RegisterGetSP();
157 registers[sp] = 0x1234;
158
159 EXPECT_EQ(RegisterGetValue(value, registers, sp, sizeof(registers)),
160 RegisterGetSPValue(value2, registers, sizeof(registers)));
161
162 EXPECT_EQ(value, value2);
163 }
164
165 /**
166 * @tc.name: RegisterGetIPValue
167 * @tc.desc:
168 * @tc.type: FUNC
169 */
170 HWTEST_F(RegisterTest, RegisterGetIPValue, TestSize.Level1)
171 {
172 uint64_t value = 0;
173 uint64_t value2 = 0;
174 u64 registers[PERF_REG_ARM64_MAX] = {1, 2, 3, 4};
175 size_t registerIndex = 0;
176 size_t ip = RegisterGetIP();
177 registers[ip] = 0x1234;
178
179 EXPECT_EQ(RegisterGetValue(value, registers, ip, sizeof(registers)),
180 RegisterGetIPValue(value2, registers, sizeof(registers)));
181
182 EXPECT_EQ(value, value2);
183 }
184
185 /**
186 * @tc.name: RegisterGetName
187 * @tc.desc:
188 * @tc.type: FUNC
189 */
190 HWTEST_F(RegisterTest, RegisterGetName, TestSize.Level1)
191 {
192 for (unsigned i = 0; i < PERF_REG_ARM64_MAX; i++) {
193 EXPECT_EQ(RegisterGetName(i).empty(), false);
194 }
195 }
196
197 /**
198 * @tc.name: LibunwindRegIdToPrefReg
199 * @tc.desc:
200 * @tc.type: FUNC
201 */
202 HWTEST_F(RegisterTest, LibunwindRegIdToPrefReg, TestSize.Level1)
203 {
204 #if defined(target_cpu_x64)
205 unsigned max = PERF_REG_X86_64_MAX;
206 #elif defined(target_cpu_arm)
207 unsigned max = PERF_REG_ARM_MAX;
208 #elif defined(target_cpu_arm64)
209 unsigned max = PERF_REG_ARM64_MAX;
210 #endif
211 EXPECT_EQ(LibunwindRegIdToPrefReg(UNW_ARM_R13) >= 0, true);
212 EXPECT_EQ(LibunwindRegIdToPrefReg(UNW_ARM_R15) >= 0, true);
213 EXPECT_EQ(LibunwindRegIdToPrefReg(max + 1) < 0, true);
214 EXPECT_EQ(LibunwindRegIdToPrefReg(-1) < 0, true);
215 }
216 } // namespace NativeDaemon
217 } // namespace Developtools
218 } // namespace OHOS
219