1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <elf.h>
18
19 #include <gtest/gtest.h>
20
21 #include <vector>
22
23 #include "ElfInterfaceArm.h"
24 #include "Machine.h"
25 #include "Regs.h"
26
27 #include "MemoryFake.h"
28
29 class ElfInterfaceArmTest : public ::testing::Test {
30 protected:
SetUp()31 void SetUp() override {
32 memory_.Clear();
33 process_memory_.Clear();
34 }
35
36 MemoryFake memory_;
37 MemoryFake process_memory_;
38 };
39
TEST_F(ElfInterfaceArmTest,GetPrel32Addr)40 TEST_F(ElfInterfaceArmTest, GetPrel32Addr) {
41 ElfInterfaceArm interface(&memory_);
42 memory_.SetData32(0x1000, 0x230000);
43
44 uint32_t value;
45 ASSERT_TRUE(interface.GetPrel31Addr(0x1000, &value));
46 ASSERT_EQ(0x231000U, value);
47
48 memory_.SetData32(0x1000, 0x80001000);
49 ASSERT_TRUE(interface.GetPrel31Addr(0x1000, &value));
50 ASSERT_EQ(0x2000U, value);
51
52 memory_.SetData32(0x1000, 0x70001000);
53 ASSERT_TRUE(interface.GetPrel31Addr(0x1000, &value));
54 ASSERT_EQ(0xf0002000U, value);
55 }
56
TEST_F(ElfInterfaceArmTest,FindEntry_start_zero)57 TEST_F(ElfInterfaceArmTest, FindEntry_start_zero) {
58 ElfInterfaceArm interface(&memory_);
59 interface.set_start_offset(0);
60 interface.set_total_entries(10);
61
62 uint64_t entry_offset;
63 ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
64 }
65
TEST_F(ElfInterfaceArmTest,FindEntry_no_entries)66 TEST_F(ElfInterfaceArmTest, FindEntry_no_entries) {
67 ElfInterfaceArm interface(&memory_);
68 interface.set_start_offset(0x100);
69 interface.set_total_entries(0);
70
71 uint64_t entry_offset;
72 ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
73 }
74
TEST_F(ElfInterfaceArmTest,FindEntry_no_valid_memory)75 TEST_F(ElfInterfaceArmTest, FindEntry_no_valid_memory) {
76 ElfInterfaceArm interface(&memory_);
77 interface.set_start_offset(0x100);
78 interface.set_total_entries(2);
79
80 uint64_t entry_offset;
81 ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
82 }
83
TEST_F(ElfInterfaceArmTest,FindEntry_ip_before_first)84 TEST_F(ElfInterfaceArmTest, FindEntry_ip_before_first) {
85 ElfInterfaceArm interface(&memory_);
86 interface.set_start_offset(0x1000);
87 interface.set_total_entries(1);
88 memory_.SetData32(0x1000, 0x6000);
89
90 uint64_t entry_offset;
91 ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
92 }
93
TEST_F(ElfInterfaceArmTest,FindEntry_single_entry_negative_value)94 TEST_F(ElfInterfaceArmTest, FindEntry_single_entry_negative_value) {
95 ElfInterfaceArm interface(&memory_);
96 interface.set_start_offset(0x8000);
97 interface.set_total_entries(1);
98 memory_.SetData32(0x8000, 0x7fffff00);
99
100 uint64_t entry_offset;
101 ASSERT_TRUE(interface.FindEntry(0x7ff0, &entry_offset));
102 ASSERT_EQ(0x8000U, entry_offset);
103 }
104
TEST_F(ElfInterfaceArmTest,FindEntry_two_entries)105 TEST_F(ElfInterfaceArmTest, FindEntry_two_entries) {
106 ElfInterfaceArm interface(&memory_);
107 interface.set_start_offset(0x1000);
108 interface.set_total_entries(2);
109 memory_.SetData32(0x1000, 0x6000);
110 memory_.SetData32(0x1008, 0x7000);
111
112 uint64_t entry_offset;
113 ASSERT_TRUE(interface.FindEntry(0x7000, &entry_offset));
114 ASSERT_EQ(0x1000U, entry_offset);
115 }
116
117
TEST_F(ElfInterfaceArmTest,FindEntry_last_check_single_entry)118 TEST_F(ElfInterfaceArmTest, FindEntry_last_check_single_entry) {
119 ElfInterfaceArm interface(&memory_);
120 interface.set_start_offset(0x1000);
121 interface.set_total_entries(1);
122 memory_.SetData32(0x1000, 0x6000);
123
124 uint64_t entry_offset;
125 ASSERT_TRUE(interface.FindEntry(0x7000, &entry_offset));
126 ASSERT_EQ(0x1000U, entry_offset);
127
128 // To guarantee that we are using the cache on the second run,
129 // set the memory to a different value.
130 memory_.SetData32(0x1000, 0x8000);
131 ASSERT_TRUE(interface.FindEntry(0x7004, &entry_offset));
132 ASSERT_EQ(0x1000U, entry_offset);
133 }
134
TEST_F(ElfInterfaceArmTest,FindEntry_last_check_multiple_entries)135 TEST_F(ElfInterfaceArmTest, FindEntry_last_check_multiple_entries) {
136 ElfInterfaceArm interface(&memory_);
137 interface.set_start_offset(0x1000);
138 interface.set_total_entries(2);
139 memory_.SetData32(0x1000, 0x6000);
140 memory_.SetData32(0x1008, 0x8000);
141
142 uint64_t entry_offset;
143 ASSERT_TRUE(interface.FindEntry(0x9008, &entry_offset));
144 ASSERT_EQ(0x1008U, entry_offset);
145
146 // To guarantee that we are using the cache on the second run,
147 // set the memory to a different value.
148 memory_.SetData32(0x1000, 0x16000);
149 memory_.SetData32(0x1008, 0x18000);
150 ASSERT_TRUE(interface.FindEntry(0x9100, &entry_offset));
151 ASSERT_EQ(0x1008U, entry_offset);
152 }
153
TEST_F(ElfInterfaceArmTest,FindEntry_multiple_entries_even)154 TEST_F(ElfInterfaceArmTest, FindEntry_multiple_entries_even) {
155 ElfInterfaceArm interface(&memory_);
156 interface.set_start_offset(0x1000);
157 interface.set_total_entries(4);
158 memory_.SetData32(0x1000, 0x6000);
159 memory_.SetData32(0x1008, 0x7000);
160 memory_.SetData32(0x1010, 0x8000);
161 memory_.SetData32(0x1018, 0x9000);
162
163 uint64_t entry_offset;
164 ASSERT_TRUE(interface.FindEntry(0x9100, &entry_offset));
165 ASSERT_EQ(0x1010U, entry_offset);
166
167 // To guarantee that we are using the cache on the second run,
168 // set the memory to a different value.
169 memory_.SetData32(0x1000, 0x16000);
170 memory_.SetData32(0x1008, 0x17000);
171 memory_.SetData32(0x1010, 0x18000);
172 memory_.SetData32(0x1018, 0x19000);
173 ASSERT_TRUE(interface.FindEntry(0x9100, &entry_offset));
174 ASSERT_EQ(0x1010U, entry_offset);
175 }
176
TEST_F(ElfInterfaceArmTest,FindEntry_multiple_entries_odd)177 TEST_F(ElfInterfaceArmTest, FindEntry_multiple_entries_odd) {
178 ElfInterfaceArm interface(&memory_);
179 interface.set_start_offset(0x1000);
180 interface.set_total_entries(5);
181 memory_.SetData32(0x1000, 0x5000);
182 memory_.SetData32(0x1008, 0x6000);
183 memory_.SetData32(0x1010, 0x7000);
184 memory_.SetData32(0x1018, 0x8000);
185 memory_.SetData32(0x1020, 0x9000);
186
187 uint64_t entry_offset;
188 ASSERT_TRUE(interface.FindEntry(0x8100, &entry_offset));
189 ASSERT_EQ(0x1010U, entry_offset);
190
191 // To guarantee that we are using the cache on the second run,
192 // set the memory to a different value.
193 memory_.SetData32(0x1000, 0x15000);
194 memory_.SetData32(0x1008, 0x16000);
195 memory_.SetData32(0x1010, 0x17000);
196 memory_.SetData32(0x1018, 0x18000);
197 memory_.SetData32(0x1020, 0x19000);
198 ASSERT_TRUE(interface.FindEntry(0x8100, &entry_offset));
199 ASSERT_EQ(0x1010U, entry_offset);
200 }
201
TEST_F(ElfInterfaceArmTest,iterate)202 TEST_F(ElfInterfaceArmTest, iterate) {
203 ElfInterfaceArm interface(&memory_);
204 interface.set_start_offset(0x1000);
205 interface.set_total_entries(5);
206 memory_.SetData32(0x1000, 0x5000);
207 memory_.SetData32(0x1008, 0x6000);
208 memory_.SetData32(0x1010, 0x7000);
209 memory_.SetData32(0x1018, 0x8000);
210 memory_.SetData32(0x1020, 0x9000);
211
212 std::vector<uint32_t> entries;
213 for (auto addr : interface) {
214 entries.push_back(addr);
215 }
216 ASSERT_EQ(5U, entries.size());
217 ASSERT_EQ(0x6000U, entries[0]);
218 ASSERT_EQ(0x7008U, entries[1]);
219 ASSERT_EQ(0x8010U, entries[2]);
220 ASSERT_EQ(0x9018U, entries[3]);
221 ASSERT_EQ(0xa020U, entries[4]);
222
223 // Make sure the iterate cached the entries.
224 memory_.SetData32(0x1000, 0x11000);
225 memory_.SetData32(0x1008, 0x12000);
226 memory_.SetData32(0x1010, 0x13000);
227 memory_.SetData32(0x1018, 0x14000);
228 memory_.SetData32(0x1020, 0x15000);
229
230 entries.clear();
231 for (auto addr : interface) {
232 entries.push_back(addr);
233 }
234 ASSERT_EQ(5U, entries.size());
235 ASSERT_EQ(0x6000U, entries[0]);
236 ASSERT_EQ(0x7008U, entries[1]);
237 ASSERT_EQ(0x8010U, entries[2]);
238 ASSERT_EQ(0x9018U, entries[3]);
239 ASSERT_EQ(0xa020U, entries[4]);
240 }
241
TEST_F(ElfInterfaceArmTest,FindEntry_load_bias)242 TEST_F(ElfInterfaceArmTest, FindEntry_load_bias) {
243 ElfInterfaceArm interface(&memory_);
244 interface.set_start_offset(0x1000);
245 interface.set_total_entries(2);
246 memory_.SetData32(0x1000, 0x6000);
247 memory_.SetData32(0x1008, 0x8000);
248
249 uint64_t entry_offset;
250 interface.set_load_bias(0x2000);
251 ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
252 ASSERT_FALSE(interface.FindEntry(0x8000, &entry_offset));
253 ASSERT_FALSE(interface.FindEntry(0x8fff, &entry_offset));
254 ASSERT_TRUE(interface.FindEntry(0x9000, &entry_offset));
255 ASSERT_EQ(0x1000U, entry_offset);
256 ASSERT_TRUE(interface.FindEntry(0xb007, &entry_offset));
257 ASSERT_EQ(0x1000U, entry_offset);
258 ASSERT_TRUE(interface.FindEntry(0xb008, &entry_offset));
259 ASSERT_EQ(0x1008U, entry_offset);
260 }
261
TEST_F(ElfInterfaceArmTest,HandleType_not_arm_exidx)262 TEST_F(ElfInterfaceArmTest, HandleType_not_arm_exidx) {
263 ElfInterfaceArm interface(&memory_);
264
265 ASSERT_FALSE(interface.HandleType(0x1000, PT_NULL));
266 ASSERT_FALSE(interface.HandleType(0x1000, PT_LOAD));
267 ASSERT_FALSE(interface.HandleType(0x1000, PT_DYNAMIC));
268 ASSERT_FALSE(interface.HandleType(0x1000, PT_INTERP));
269 ASSERT_FALSE(interface.HandleType(0x1000, PT_NOTE));
270 ASSERT_FALSE(interface.HandleType(0x1000, PT_SHLIB));
271 ASSERT_FALSE(interface.HandleType(0x1000, PT_PHDR));
272 ASSERT_FALSE(interface.HandleType(0x1000, PT_TLS));
273 ASSERT_FALSE(interface.HandleType(0x1000, PT_LOOS));
274 ASSERT_FALSE(interface.HandleType(0x1000, PT_HIOS));
275 ASSERT_FALSE(interface.HandleType(0x1000, PT_LOPROC));
276 ASSERT_FALSE(interface.HandleType(0x1000, PT_HIPROC));
277 ASSERT_FALSE(interface.HandleType(0x1000, PT_GNU_EH_FRAME));
278 ASSERT_FALSE(interface.HandleType(0x1000, PT_GNU_STACK));
279 }
280
TEST_F(ElfInterfaceArmTest,HandleType_arm_exidx)281 TEST_F(ElfInterfaceArmTest, HandleType_arm_exidx) {
282 ElfInterfaceArm interface(&memory_);
283
284 Elf32_Phdr phdr;
285 interface.set_start_offset(0x1000);
286 interface.set_total_entries(100);
287 phdr.p_vaddr = 0x2000;
288 phdr.p_memsz = 0xa00;
289
290 // Verify that if reads fail, we don't set the values but still get true.
291 ASSERT_TRUE(interface.HandleType(0x1000, 0x70000001));
292 ASSERT_EQ(0x1000U, interface.start_offset());
293 ASSERT_EQ(100U, interface.total_entries());
294
295 // Verify that if the second read fails, we still don't set the values.
296 memory_.SetData32(
297 0x1000 + reinterpret_cast<uint64_t>(&phdr.p_vaddr) - reinterpret_cast<uint64_t>(&phdr),
298 phdr.p_vaddr);
299 ASSERT_TRUE(interface.HandleType(0x1000, 0x70000001));
300 ASSERT_EQ(0x1000U, interface.start_offset());
301 ASSERT_EQ(100U, interface.total_entries());
302
303 // Everything is correct and present.
304 memory_.SetData32(
305 0x1000 + reinterpret_cast<uint64_t>(&phdr.p_memsz) - reinterpret_cast<uint64_t>(&phdr),
306 phdr.p_memsz);
307 ASSERT_TRUE(interface.HandleType(0x1000, 0x70000001));
308 ASSERT_EQ(0x2000U, interface.start_offset());
309 ASSERT_EQ(320U, interface.total_entries());
310
311 // Non-zero load bias.
312 interface.set_load_bias(0x1000);
313 ASSERT_TRUE(interface.HandleType(0x1000, 0x70000001));
314 ASSERT_EQ(0x1000U, interface.start_offset());
315 ASSERT_EQ(320U, interface.total_entries());
316 }
317
TEST_F(ElfInterfaceArmTest,StepExidx)318 TEST_F(ElfInterfaceArmTest, StepExidx) {
319 ElfInterfaceArm interface(&memory_);
320
321 // FindEntry fails.
322 ASSERT_FALSE(interface.StepExidx(0x7000, nullptr, nullptr));
323
324 // ExtractEntry should fail.
325 interface.set_start_offset(0x1000);
326 interface.set_total_entries(2);
327 memory_.SetData32(0x1000, 0x6000);
328 memory_.SetData32(0x1008, 0x8000);
329
330 RegsArm regs;
331 regs[ARM_REG_SP] = 0x1000;
332 regs[ARM_REG_LR] = 0x20000;
333 regs.set_sp(regs[ARM_REG_SP]);
334 regs.set_pc(0x1234);
335 ASSERT_FALSE(interface.StepExidx(0x7000, ®s, &process_memory_));
336
337 // Eval should fail.
338 memory_.SetData32(0x1004, 0x81000000);
339 ASSERT_FALSE(interface.StepExidx(0x7000, ®s, &process_memory_));
340
341 // Everything should pass.
342 memory_.SetData32(0x1004, 0x80b0b0b0);
343 ASSERT_TRUE(interface.StepExidx(0x7000, ®s, &process_memory_));
344 ASSERT_EQ(0x1000U, regs.sp());
345 ASSERT_EQ(0x1000U, regs[ARM_REG_SP]);
346 ASSERT_EQ(0x20000U, regs.pc());
347 ASSERT_EQ(0x20000U, regs[ARM_REG_PC]);
348 }
349
TEST_F(ElfInterfaceArmTest,StepExidx_pc_set)350 TEST_F(ElfInterfaceArmTest, StepExidx_pc_set) {
351 ElfInterfaceArm interface(&memory_);
352
353 interface.set_start_offset(0x1000);
354 interface.set_total_entries(2);
355 memory_.SetData32(0x1000, 0x6000);
356 memory_.SetData32(0x1004, 0x808800b0);
357 memory_.SetData32(0x1008, 0x8000);
358 process_memory_.SetData32(0x10000, 0x10);
359
360 RegsArm regs;
361 regs[ARM_REG_SP] = 0x10000;
362 regs[ARM_REG_LR] = 0x20000;
363 regs.set_sp(regs[ARM_REG_SP]);
364 regs.set_pc(0x1234);
365
366 // Everything should pass.
367 ASSERT_TRUE(interface.StepExidx(0x7000, ®s, &process_memory_));
368 ASSERT_EQ(0x10004U, regs.sp());
369 ASSERT_EQ(0x10004U, regs[ARM_REG_SP]);
370 ASSERT_EQ(0x10U, regs.pc());
371 ASSERT_EQ(0x10U, regs[ARM_REG_PC]);
372 }
373