1 /*
2 * Copyright (C) 2017 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 #include <stdint.h>
19 #include <sys/mman.h>
20
21 #include <memory>
22 #include <set>
23 #include <string>
24
25 #include <gtest/gtest.h>
26
27 #include <unwindstack/Elf.h>
28 #include <unwindstack/Maps.h>
29 #include <unwindstack/Memory.h>
30 #include <unwindstack/Regs.h>
31 #include <unwindstack/RegsArm.h>
32 #include <unwindstack/RegsArm64.h>
33 #include <unwindstack/RegsX86.h>
34 #include <unwindstack/RegsX86_64.h>
35 #include <unwindstack/RegsMips.h>
36 #include <unwindstack/RegsMips64.h>
37 #include <unwindstack/Unwinder.h>
38
39 #include "ElfFake.h"
40 #include "MemoryFake.h"
41 #include "RegsFake.h"
42
43 namespace unwindstack {
44
45 class UnwinderTest : public ::testing::Test {
46 protected:
AddMapInfo(uint64_t start,uint64_t end,uint64_t offset,uint64_t flags,const char * name,Elf * elf=nullptr)47 static void AddMapInfo(uint64_t start, uint64_t end, uint64_t offset, uint64_t flags,
48 const char* name, Elf* elf = nullptr) {
49 std::string str_name(name);
50 maps_->Add(start, end, offset, flags, name, static_cast<uint64_t>(-1));
51 if (elf != nullptr) {
52 const auto& map_info = *--maps_->end();
53 map_info->elf.reset(elf);
54 }
55 }
56
SetUpTestSuite()57 static void SetUpTestSuite() {
58 maps_.reset(new Maps);
59
60 ElfFake* elf = new ElfFake(new MemoryFake);
61 ElfInterfaceFake* interface_fake = new ElfInterfaceFake(nullptr);
62 interface_fake->FakeSetBuildID("FAKE");
63 elf->FakeSetInterface(interface_fake);
64 AddMapInfo(0x1000, 0x8000, 0, PROT_READ | PROT_WRITE, "/system/fake/libc.so", elf);
65
66 AddMapInfo(0x10000, 0x12000, 0, PROT_READ | PROT_WRITE, "[stack]");
67
68 AddMapInfo(0x13000, 0x15000, 0, PROT_READ | PROT_WRITE | MAPS_FLAGS_DEVICE_MAP,
69 "/dev/fake_device");
70
71 elf = new ElfFake(new MemoryFake);
72 elf->FakeSetInterface(new ElfInterfaceFake(nullptr));
73 AddMapInfo(0x20000, 0x22000, 0, PROT_READ | PROT_WRITE, "/system/fake/libunwind.so", elf);
74
75 elf = new ElfFake(new MemoryFake);
76 elf->FakeSetInterface(new ElfInterfaceFake(nullptr));
77 AddMapInfo(0x23000, 0x24000, 0, PROT_READ | PROT_WRITE, "/fake/libanother.so", elf);
78
79 elf = new ElfFake(new MemoryFake);
80 elf->FakeSetInterface(new ElfInterfaceFake(nullptr));
81 AddMapInfo(0x33000, 0x34000, 0, PROT_READ | PROT_WRITE, "/fake/compressed.so", elf);
82
83 elf = new ElfFake(new MemoryFake);
84 ElfInterfaceFake* interface = new ElfInterfaceFake(nullptr);
85 interface->FakeSetSoname("lib_fake.so");
86 elf->FakeSetInterface(interface);
87 AddMapInfo(0x43000, 0x44000, 0x1d000, PROT_READ | PROT_WRITE, "/fake/fake.apk", elf);
88 MapInfo* map_info = maps_->Find(0x43000);
89 ASSERT_TRUE(map_info != nullptr);
90 map_info->elf_start_offset = 0x1d000;
91
92 AddMapInfo(0x53000, 0x54000, 0, PROT_READ | PROT_WRITE, "/fake/fake.oat");
93
94 AddMapInfo(0xa3000, 0xa4000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "/fake/fake.vdex");
95 const auto& info = *--maps_->end();
96 info->load_bias = 0;
97
98 elf = new ElfFake(new MemoryFake);
99 elf->FakeSetInterface(new ElfInterfaceFake(nullptr));
100 elf->FakeSetLoadBias(0x5000);
101 AddMapInfo(0xa5000, 0xa6000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "/fake/fake_load_bias.so",
102 elf);
103
104 elf = new ElfFake(new MemoryFake);
105 elf->FakeSetInterface(new ElfInterfaceFake(nullptr));
106 AddMapInfo(0xa7000, 0xa8000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "/fake/fake_offset.oat",
107 elf);
108 const auto& info2 = *--maps_->end();
109 info2->elf_offset = 0x8000;
110
111 elf = new ElfFake(new MemoryFake);
112 elf->FakeSetInterface(new ElfInterfaceFake(nullptr));
113 AddMapInfo(0xc0000, 0xc1000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "/fake/unreadable.so", elf);
114 const auto& info3 = *--maps_->end();
115 info3->memory_backed_elf = true;
116
117 elf = new ElfFake(new MemoryFake);
118 elf->FakeSetInterface(new ElfInterfaceFake(nullptr));
119 AddMapInfo(0xc1000, 0xc2000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "[vdso]", elf);
120 const auto& info4 = *--maps_->end();
121 info4->memory_backed_elf = true;
122
123 elf = new ElfFake(new MemoryFake);
124 elf->FakeSetInterface(new ElfInterfaceFake(nullptr));
125 AddMapInfo(0xc2000, 0xc3000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "", elf);
126 const auto& info5 = *--maps_->end();
127 info5->memory_backed_elf = true;
128
129 elf = new ElfFake(new MemoryFake);
130 elf->FakeSetInterface(new ElfInterfaceFake(nullptr));
131 AddMapInfo(0xc3000, 0xc4000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "/memfd:/jit-cache", elf);
132 const auto& info6 = *--maps_->end();
133 info6->memory_backed_elf = true;
134
135 AddMapInfo(0xd0000, 0xd1000, 0x1000, PROT_READ | PROT_WRITE | PROT_EXEC, "/fake/fake.apk");
136 const auto& info7 = *--maps_->end();
137 info7->load_bias = 0;
138
139 process_memory_.reset(new MemoryFake);
140 }
141
SetUp()142 void SetUp() override {
143 ElfInterfaceFake::FakeClear();
144 regs_.FakeSetArch(ARCH_ARM);
145 regs_.FakeSetReturnAddressValid(false);
146 }
147
148 static std::unique_ptr<Maps> maps_;
149 static RegsFake regs_;
150 static std::shared_ptr<Memory> process_memory_;
151 };
152
153 std::unique_ptr<Maps> UnwinderTest::maps_;
154 RegsFake UnwinderTest::regs_(5);
155 std::shared_ptr<Memory> UnwinderTest::process_memory_(nullptr);
156
TEST_F(UnwinderTest,multiple_frames)157 TEST_F(UnwinderTest, multiple_frames) {
158 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
159 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
160 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
161
162 regs_.set_pc(0x1000);
163 regs_.set_sp(0x10000);
164 ElfInterfaceFake::FakePushStepData(StepData(0x1102, 0x10010, false));
165 ElfInterfaceFake::FakePushStepData(StepData(0x1202, 0x10020, false));
166 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
167
168 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
169 unwinder.Unwind();
170 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
171 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
172
173 ASSERT_EQ(3U, unwinder.NumFrames());
174
175 auto* frame = &unwinder.frames()[0];
176 EXPECT_EQ(0U, frame->num);
177 EXPECT_EQ(0U, frame->rel_pc);
178 EXPECT_EQ(0x1000U, frame->pc);
179 EXPECT_EQ(0x10000U, frame->sp);
180 EXPECT_EQ("Frame0", frame->function_name);
181 EXPECT_EQ(0U, frame->function_offset);
182 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
183 EXPECT_EQ(0U, frame->map_elf_start_offset);
184 EXPECT_EQ(0U, frame->map_exact_offset);
185 EXPECT_EQ(0x1000U, frame->map_start);
186 EXPECT_EQ(0x8000U, frame->map_end);
187 EXPECT_EQ(0U, frame->map_load_bias);
188 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
189
190 frame = &unwinder.frames()[1];
191 EXPECT_EQ(1U, frame->num);
192 EXPECT_EQ(0x100U, frame->rel_pc);
193 EXPECT_EQ(0x1100U, frame->pc);
194 EXPECT_EQ(0x10010U, frame->sp);
195 EXPECT_EQ("Frame1", frame->function_name);
196 EXPECT_EQ(1U, frame->function_offset);
197 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
198 EXPECT_EQ(0U, frame->map_elf_start_offset);
199 EXPECT_EQ(0U, frame->map_exact_offset);
200 EXPECT_EQ(0x1000U, frame->map_start);
201 EXPECT_EQ(0x8000U, frame->map_end);
202 EXPECT_EQ(0U, frame->map_load_bias);
203 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
204
205 frame = &unwinder.frames()[2];
206 EXPECT_EQ(2U, frame->num);
207 EXPECT_EQ(0x200U, frame->rel_pc);
208 EXPECT_EQ(0x1200U, frame->pc);
209 EXPECT_EQ(0x10020U, frame->sp);
210 EXPECT_EQ("Frame2", frame->function_name);
211 EXPECT_EQ(2U, frame->function_offset);
212 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
213 EXPECT_EQ(0U, frame->map_elf_start_offset);
214 EXPECT_EQ(0U, frame->map_exact_offset);
215 EXPECT_EQ(0x1000U, frame->map_start);
216 EXPECT_EQ(0x8000U, frame->map_end);
217 EXPECT_EQ(0U, frame->map_load_bias);
218 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
219 }
220
TEST_F(UnwinderTest,multiple_frames_dont_resolve_names)221 TEST_F(UnwinderTest, multiple_frames_dont_resolve_names) {
222 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
223 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
224 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
225
226 regs_.set_pc(0x1000);
227 regs_.set_sp(0x10000);
228 ElfInterfaceFake::FakePushStepData(StepData(0x1102, 0x10010, false));
229 ElfInterfaceFake::FakePushStepData(StepData(0x1202, 0x10020, false));
230 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
231
232 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
233 unwinder.SetResolveNames(false);
234 unwinder.Unwind();
235 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
236 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
237
238 ASSERT_EQ(3U, unwinder.NumFrames());
239
240 auto* frame = &unwinder.frames()[0];
241 EXPECT_EQ(0U, frame->num);
242 EXPECT_EQ(0U, frame->rel_pc);
243 EXPECT_EQ(0x1000U, frame->pc);
244 EXPECT_EQ(0x10000U, frame->sp);
245 EXPECT_EQ("", frame->function_name);
246 EXPECT_EQ(0U, frame->function_offset);
247 EXPECT_EQ("", frame->map_name);
248 EXPECT_EQ(0U, frame->map_elf_start_offset);
249 EXPECT_EQ(0U, frame->map_exact_offset);
250 EXPECT_EQ(0x1000U, frame->map_start);
251 EXPECT_EQ(0x8000U, frame->map_end);
252 EXPECT_EQ(0U, frame->map_load_bias);
253 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
254
255 frame = &unwinder.frames()[1];
256 EXPECT_EQ(1U, frame->num);
257 EXPECT_EQ(0x100U, frame->rel_pc);
258 EXPECT_EQ(0x1100U, frame->pc);
259 EXPECT_EQ(0x10010U, frame->sp);
260 EXPECT_EQ("", frame->function_name);
261 EXPECT_EQ(0U, frame->function_offset);
262 EXPECT_EQ("", frame->map_name);
263 EXPECT_EQ(0U, frame->map_elf_start_offset);
264 EXPECT_EQ(0U, frame->map_exact_offset);
265 EXPECT_EQ(0x1000U, frame->map_start);
266 EXPECT_EQ(0x8000U, frame->map_end);
267 EXPECT_EQ(0U, frame->map_load_bias);
268 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
269
270 frame = &unwinder.frames()[2];
271 EXPECT_EQ(2U, frame->num);
272 EXPECT_EQ(0x200U, frame->rel_pc);
273 EXPECT_EQ(0x1200U, frame->pc);
274 EXPECT_EQ(0x10020U, frame->sp);
275 EXPECT_EQ("", frame->function_name);
276 EXPECT_EQ(0U, frame->function_offset);
277 EXPECT_EQ("", frame->map_name);
278 EXPECT_EQ(0U, frame->map_elf_start_offset);
279 EXPECT_EQ(0U, frame->map_exact_offset);
280 EXPECT_EQ(0x1000U, frame->map_start);
281 EXPECT_EQ(0x8000U, frame->map_end);
282 EXPECT_EQ(0U, frame->map_load_bias);
283 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
284 }
285
TEST_F(UnwinderTest,non_zero_load_bias)286 TEST_F(UnwinderTest, non_zero_load_bias) {
287 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
288
289 regs_.set_pc(0xa5500);
290 regs_.set_sp(0x10000);
291 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
292
293 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
294 unwinder.Unwind();
295 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
296 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
297
298 ASSERT_EQ(1U, unwinder.NumFrames());
299
300 auto* frame = &unwinder.frames()[0];
301 EXPECT_EQ(0U, frame->num);
302 EXPECT_EQ(0x5500U, frame->rel_pc);
303 EXPECT_EQ(0xa5500U, frame->pc);
304 EXPECT_EQ(0x10000U, frame->sp);
305 EXPECT_EQ("Frame0", frame->function_name);
306 EXPECT_EQ(0U, frame->function_offset);
307 EXPECT_EQ("/fake/fake_load_bias.so", frame->map_name);
308 EXPECT_EQ(0U, frame->map_elf_start_offset);
309 EXPECT_EQ(0U, frame->map_exact_offset);
310 EXPECT_EQ(0xa5000U, frame->map_start);
311 EXPECT_EQ(0xa6000U, frame->map_end);
312 EXPECT_EQ(0x5000U, frame->map_load_bias);
313 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags);
314 }
315
TEST_F(UnwinderTest,non_zero_elf_offset)316 TEST_F(UnwinderTest, non_zero_elf_offset) {
317 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
318
319 regs_.set_pc(0xa7500);
320 regs_.set_sp(0x10000);
321 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
322
323 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
324 unwinder.Unwind();
325 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
326 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
327
328 ASSERT_EQ(1U, unwinder.NumFrames());
329
330 auto* frame = &unwinder.frames()[0];
331 EXPECT_EQ(0U, frame->num);
332 EXPECT_EQ(0x8500U, frame->rel_pc);
333 EXPECT_EQ(0xa7500U, frame->pc);
334 EXPECT_EQ(0x10000U, frame->sp);
335 EXPECT_EQ("Frame0", frame->function_name);
336 EXPECT_EQ(0U, frame->function_offset);
337 EXPECT_EQ("/fake/fake_offset.oat", frame->map_name);
338 EXPECT_EQ(0U, frame->map_elf_start_offset);
339 EXPECT_EQ(0U, frame->map_exact_offset);
340 EXPECT_EQ(0xa7000U, frame->map_start);
341 EXPECT_EQ(0xa8000U, frame->map_end);
342 EXPECT_EQ(0U, frame->map_load_bias);
343 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags);
344 }
345
TEST_F(UnwinderTest,non_zero_map_offset)346 TEST_F(UnwinderTest, non_zero_map_offset) {
347 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
348
349 regs_.set_pc(0x43000);
350 regs_.set_sp(0x10000);
351 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
352
353 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
354 unwinder.Unwind();
355 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
356 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
357
358 ASSERT_EQ(1U, unwinder.NumFrames());
359
360 auto* frame = &unwinder.frames()[0];
361 EXPECT_EQ(0U, frame->num);
362 EXPECT_EQ(0U, frame->rel_pc);
363 EXPECT_EQ(0x43000U, frame->pc);
364 EXPECT_EQ(0x10000U, frame->sp);
365 EXPECT_EQ("Frame0", frame->function_name);
366 EXPECT_EQ(0U, frame->function_offset);
367 EXPECT_EQ("/fake/fake.apk!lib_fake.so", frame->map_name);
368 EXPECT_EQ(0x1d000U, frame->map_elf_start_offset);
369 EXPECT_EQ(0x1d000U, frame->map_exact_offset);
370 EXPECT_EQ(0x43000U, frame->map_start);
371 EXPECT_EQ(0x44000U, frame->map_end);
372 EXPECT_EQ(0U, frame->map_load_bias);
373 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
374 }
375
TEST_F(UnwinderTest,disable_embedded_soname)376 TEST_F(UnwinderTest, disable_embedded_soname) {
377 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
378
379 regs_.set_pc(0x43000);
380 regs_.set_sp(0x10000);
381 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
382
383 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
384 unwinder.SetEmbeddedSoname(false);
385 unwinder.Unwind();
386 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
387 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
388
389 ASSERT_EQ(1U, unwinder.NumFrames());
390
391 auto* frame = &unwinder.frames()[0];
392 EXPECT_EQ(0U, frame->num);
393 EXPECT_EQ(0U, frame->rel_pc);
394 EXPECT_EQ(0x43000U, frame->pc);
395 EXPECT_EQ(0x10000U, frame->sp);
396 EXPECT_EQ("Frame0", frame->function_name);
397 EXPECT_EQ(0U, frame->function_offset);
398 EXPECT_EQ("/fake/fake.apk", frame->map_name);
399 EXPECT_EQ(0x1d000U, frame->map_elf_start_offset);
400 EXPECT_EQ(0x1d000U, frame->map_exact_offset);
401 EXPECT_EQ(0x43000U, frame->map_start);
402 EXPECT_EQ(0x44000U, frame->map_end);
403 EXPECT_EQ(0U, frame->map_load_bias);
404 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
405 }
406
407 // Verify that no attempt to continue after the step indicates it is done.
TEST_F(UnwinderTest,no_frames_after_finished)408 TEST_F(UnwinderTest, no_frames_after_finished) {
409 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
410 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
411 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
412 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame3", 3));
413 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame4", 4));
414
415 regs_.set_pc(0x1000);
416 regs_.set_sp(0x10000);
417 ElfInterfaceFake::FakePushStepData(StepData(0x1000, 0x10000, true));
418 ElfInterfaceFake::FakePushStepData(StepData(0x1102, 0x10010, false));
419 ElfInterfaceFake::FakePushStepData(StepData(0x1202, 0x10020, false));
420
421 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
422 unwinder.Unwind();
423 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
424 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
425
426 ASSERT_EQ(1U, unwinder.NumFrames());
427
428 auto* frame = &unwinder.frames()[0];
429 EXPECT_EQ(0U, frame->num);
430 EXPECT_EQ(0U, frame->rel_pc);
431 EXPECT_EQ(0x1000U, frame->pc);
432 EXPECT_EQ(0x10000U, frame->sp);
433 EXPECT_EQ("Frame0", frame->function_name);
434 EXPECT_EQ(0U, frame->function_offset);
435 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
436 EXPECT_EQ(0U, frame->map_elf_start_offset);
437 EXPECT_EQ(0U, frame->map_exact_offset);
438 EXPECT_EQ(0x1000U, frame->map_start);
439 EXPECT_EQ(0x8000U, frame->map_end);
440 EXPECT_EQ(0U, frame->map_load_bias);
441 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
442 }
443
444 // Verify the maximum frames to save.
TEST_F(UnwinderTest,max_frames)445 TEST_F(UnwinderTest, max_frames) {
446 for (size_t i = 0; i < 30; i++) {
447 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame" + std::to_string(i), i));
448 ElfInterfaceFake::FakePushStepData(StepData(0x1102 + i * 0x100, 0x10010 + i * 0x10, false));
449 }
450
451 regs_.set_pc(0x1000);
452 regs_.set_sp(0x10000);
453
454 Unwinder unwinder(20, maps_.get(), ®s_, process_memory_);
455 unwinder.Unwind();
456 EXPECT_EQ(ERROR_MAX_FRAMES_EXCEEDED, unwinder.LastErrorCode());
457 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
458
459 ASSERT_EQ(20U, unwinder.NumFrames());
460
461 for (size_t i = 0; i < 20; i++) {
462 auto* frame = &unwinder.frames()[i];
463 EXPECT_EQ(i, frame->num);
464 EXPECT_EQ(i * 0x100, frame->rel_pc) << "Failed at frame " << i;
465 EXPECT_EQ(0x1000 + i * 0x100, frame->pc) << "Failed at frame " << i;
466 EXPECT_EQ(0x10000 + 0x10 * i, frame->sp) << "Failed at frame " << i;
467 EXPECT_EQ("Frame" + std::to_string(i), frame->function_name) << "Failed at frame " << i;
468 EXPECT_EQ(i, frame->function_offset) << "Failed at frame " << i;
469 EXPECT_EQ("/system/fake/libc.so", frame->map_name) << "Failed at frame " << i;
470 EXPECT_EQ(0U, frame->map_elf_start_offset) << "Failed at frame " << i;
471 EXPECT_EQ(0U, frame->map_exact_offset) << "Failed at frame " << i;
472 EXPECT_EQ(0x1000U, frame->map_start) << "Failed at frame " << i;
473 EXPECT_EQ(0x8000U, frame->map_end) << "Failed at frame " << i;
474 EXPECT_EQ(0U, frame->map_load_bias) << "Failed at frame " << i;
475 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags) << "Failed at frame " << i;
476 }
477 }
478
479 // Verify that initial map names frames are removed.
TEST_F(UnwinderTest,verify_frames_skipped)480 TEST_F(UnwinderTest, verify_frames_skipped) {
481 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
482 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
483 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
484
485 regs_.set_pc(0x20000);
486 regs_.set_sp(0x10000);
487 ElfInterfaceFake::FakePushStepData(StepData(0x23002, 0x10010, false));
488 ElfInterfaceFake::FakePushStepData(StepData(0x23102, 0x10020, false));
489 ElfInterfaceFake::FakePushStepData(StepData(0x20002, 0x10030, false));
490 ElfInterfaceFake::FakePushStepData(StepData(0x21002, 0x10040, false));
491 ElfInterfaceFake::FakePushStepData(StepData(0x1002, 0x10050, false));
492 ElfInterfaceFake::FakePushStepData(StepData(0x21002, 0x10060, false));
493 ElfInterfaceFake::FakePushStepData(StepData(0x23002, 0x10070, false));
494 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
495
496 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
497 std::vector<std::string> skip_libs{"libunwind.so", "libanother.so"};
498 unwinder.Unwind(&skip_libs);
499 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
500 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
501
502 ASSERT_EQ(3U, unwinder.NumFrames());
503
504 auto* frame = &unwinder.frames()[0];
505 EXPECT_EQ(0U, frame->num);
506 EXPECT_EQ(0U, frame->rel_pc);
507 EXPECT_EQ(0x1000U, frame->pc);
508 EXPECT_EQ(0x10050U, frame->sp);
509 EXPECT_EQ("Frame0", frame->function_name);
510 EXPECT_EQ(0U, frame->function_offset);
511 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
512 EXPECT_EQ(0U, frame->map_elf_start_offset);
513 EXPECT_EQ(0U, frame->map_exact_offset);
514 EXPECT_EQ(0x1000U, frame->map_start);
515 EXPECT_EQ(0x8000U, frame->map_end);
516 EXPECT_EQ(0U, frame->map_load_bias);
517 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
518
519 frame = &unwinder.frames()[1];
520 EXPECT_EQ(1U, frame->num);
521 EXPECT_EQ(0x1000U, frame->rel_pc);
522 EXPECT_EQ(0x21000U, frame->pc);
523 EXPECT_EQ(0x10060U, frame->sp);
524 EXPECT_EQ("Frame1", frame->function_name);
525 EXPECT_EQ(1U, frame->function_offset);
526 EXPECT_EQ("/system/fake/libunwind.so", frame->map_name);
527 EXPECT_EQ(0U, frame->map_elf_start_offset);
528 EXPECT_EQ(0U, frame->map_exact_offset);
529 EXPECT_EQ(0x20000U, frame->map_start);
530 EXPECT_EQ(0x22000U, frame->map_end);
531 EXPECT_EQ(0U, frame->map_load_bias);
532 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
533
534 frame = &unwinder.frames()[2];
535 EXPECT_EQ(2U, frame->num);
536 EXPECT_EQ(0U, frame->rel_pc);
537 EXPECT_EQ(0x23000U, frame->pc);
538 EXPECT_EQ(0x10070U, frame->sp);
539 EXPECT_EQ("Frame2", frame->function_name);
540 EXPECT_EQ(2U, frame->function_offset);
541 EXPECT_EQ("/fake/libanother.so", frame->map_name);
542 EXPECT_EQ(0U, frame->map_exact_offset);
543 EXPECT_EQ(0x23000U, frame->map_start);
544 EXPECT_EQ(0x24000U, frame->map_end);
545 EXPECT_EQ(0U, frame->map_load_bias);
546 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
547 }
548
549 // Verify SP in a non-existant map is okay.
TEST_F(UnwinderTest,sp_not_in_map)550 TEST_F(UnwinderTest, sp_not_in_map) {
551 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
552 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
553
554 regs_.set_pc(0x1000);
555 regs_.set_sp(0x63000);
556 ElfInterfaceFake::FakePushStepData(StepData(0x21002, 0x50020, false));
557 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
558
559 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
560 unwinder.Unwind();
561 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
562 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
563
564 ASSERT_EQ(2U, unwinder.NumFrames());
565
566 auto* frame = &unwinder.frames()[0];
567 EXPECT_EQ(0U, frame->num);
568 EXPECT_EQ(0U, frame->rel_pc);
569 EXPECT_EQ(0x1000U, frame->pc);
570 EXPECT_EQ(0x63000U, frame->sp);
571 EXPECT_EQ("Frame0", frame->function_name);
572 EXPECT_EQ(0U, frame->function_offset);
573 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
574 EXPECT_EQ(0U, frame->map_exact_offset);
575 EXPECT_EQ(0x1000U, frame->map_start);
576 EXPECT_EQ(0x8000U, frame->map_end);
577 EXPECT_EQ(0U, frame->map_load_bias);
578 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
579
580 frame = &unwinder.frames()[1];
581 EXPECT_EQ(1U, frame->num);
582 EXPECT_EQ(0x1000U, frame->rel_pc);
583 EXPECT_EQ(0x21000U, frame->pc);
584 EXPECT_EQ(0x50020U, frame->sp);
585 EXPECT_EQ("Frame1", frame->function_name);
586 EXPECT_EQ(1U, frame->function_offset);
587 EXPECT_EQ("/system/fake/libunwind.so", frame->map_name);
588 EXPECT_EQ(0U, frame->map_exact_offset);
589 EXPECT_EQ(0x20000U, frame->map_start);
590 EXPECT_EQ(0x22000U, frame->map_end);
591 EXPECT_EQ(0U, frame->map_load_bias);
592 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
593 }
594
595 // Verify PC in a device stops the unwind.
TEST_F(UnwinderTest,pc_in_device_stops_unwind)596 TEST_F(UnwinderTest, pc_in_device_stops_unwind) {
597 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
598 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
599 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
600
601 regs_.set_pc(0x13000);
602 regs_.set_sp(0x10000);
603 ElfInterfaceFake::FakePushStepData(StepData(0x23002, 0x10010, false));
604 ElfInterfaceFake::FakePushStepData(StepData(0x23102, 0x10020, false));
605 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
606
607 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
608 unwinder.Unwind();
609 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
610 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
611
612 ASSERT_EQ(1U, unwinder.NumFrames());
613 }
614
615 // Verify SP in a device stops the unwind.
TEST_F(UnwinderTest,sp_in_device_stops_unwind)616 TEST_F(UnwinderTest, sp_in_device_stops_unwind) {
617 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
618 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
619 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
620
621 regs_.set_pc(0x1000);
622 regs_.set_sp(0x13000);
623 ElfInterfaceFake::FakePushStepData(StepData(0x23002, 0x10010, false));
624 ElfInterfaceFake::FakePushStepData(StepData(0x23102, 0x10020, false));
625 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
626
627 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
628 unwinder.Unwind();
629 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
630 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
631
632 ASSERT_EQ(1U, unwinder.NumFrames());
633 }
634
635 // Verify a no map info frame gets a frame.
TEST_F(UnwinderTest,pc_without_map)636 TEST_F(UnwinderTest, pc_without_map) {
637 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
638
639 regs_.set_pc(0x41000);
640 regs_.set_sp(0x13000);
641
642 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
643 unwinder.Unwind();
644 EXPECT_EQ(ERROR_INVALID_MAP, unwinder.LastErrorCode());
645 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
646
647 ASSERT_EQ(1U, unwinder.NumFrames());
648
649 auto* frame = &unwinder.frames()[0];
650 EXPECT_EQ(0U, frame->num);
651 EXPECT_EQ(0x41000U, frame->rel_pc);
652 EXPECT_EQ(0x41000U, frame->pc);
653 EXPECT_EQ(0x13000U, frame->sp);
654 EXPECT_EQ("", frame->function_name);
655 EXPECT_EQ(0U, frame->function_offset);
656 EXPECT_EQ("", frame->map_name);
657 EXPECT_EQ(0U, frame->map_elf_start_offset);
658 EXPECT_EQ(0U, frame->map_exact_offset);
659 EXPECT_EQ(0U, frame->map_start);
660 EXPECT_EQ(0U, frame->map_end);
661 EXPECT_EQ(0U, frame->map_load_bias);
662 EXPECT_EQ(0, frame->map_flags);
663 }
664
665 // Verify that a speculative frame is added.
TEST_F(UnwinderTest,speculative_frame)666 TEST_F(UnwinderTest, speculative_frame) {
667 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
668 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
669
670 // Fake as if code called a nullptr function.
671 regs_.set_pc(0);
672 regs_.set_sp(0x10000);
673 regs_.FakeSetReturnAddress(0x1202);
674 regs_.FakeSetReturnAddressValid(true);
675
676 ElfInterfaceFake::FakePushStepData(StepData(0x23102, 0x10020, false));
677 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
678
679 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
680 unwinder.Unwind();
681 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
682 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
683
684 ASSERT_EQ(3U, unwinder.NumFrames());
685
686 auto* frame = &unwinder.frames()[0];
687 EXPECT_EQ(0U, frame->num);
688 EXPECT_EQ(0U, frame->rel_pc);
689 EXPECT_EQ(0U, frame->pc);
690 EXPECT_EQ(0x10000U, frame->sp);
691 EXPECT_EQ("", frame->function_name);
692 EXPECT_EQ(0U, frame->function_offset);
693 EXPECT_EQ("", frame->map_name);
694 EXPECT_EQ(0U, frame->map_elf_start_offset);
695 EXPECT_EQ(0U, frame->map_exact_offset);
696 EXPECT_EQ(0U, frame->map_start);
697 EXPECT_EQ(0U, frame->map_end);
698 EXPECT_EQ(0U, frame->map_load_bias);
699 EXPECT_EQ(0, frame->map_flags);
700
701 frame = &unwinder.frames()[1];
702 EXPECT_EQ(1U, frame->num);
703 EXPECT_EQ(0x200U, frame->rel_pc);
704 EXPECT_EQ(0x1200U, frame->pc);
705 EXPECT_EQ(0x10000U, frame->sp);
706 EXPECT_EQ("Frame0", frame->function_name);
707 EXPECT_EQ(0U, frame->function_offset);
708 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
709 EXPECT_EQ(0U, frame->map_elf_start_offset);
710 EXPECT_EQ(0U, frame->map_exact_offset);
711 EXPECT_EQ(0x1000U, frame->map_start);
712 EXPECT_EQ(0x8000U, frame->map_end);
713 EXPECT_EQ(0U, frame->map_load_bias);
714 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
715
716 frame = &unwinder.frames()[2];
717 EXPECT_EQ(2U, frame->num);
718 EXPECT_EQ(0x100U, frame->rel_pc);
719 EXPECT_EQ(0x23100U, frame->pc);
720 EXPECT_EQ(0x10020U, frame->sp);
721 EXPECT_EQ("Frame1", frame->function_name);
722 EXPECT_EQ(1U, frame->function_offset);
723 EXPECT_EQ("/fake/libanother.so", frame->map_name);
724 EXPECT_EQ(0U, frame->map_elf_start_offset);
725 EXPECT_EQ(0U, frame->map_exact_offset);
726 EXPECT_EQ(0x23000U, frame->map_start);
727 EXPECT_EQ(0x24000U, frame->map_end);
728 EXPECT_EQ(0U, frame->map_load_bias);
729 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
730 }
731
732 // Verify that a speculative frame is added then removed because no other
733 // frames are added.
TEST_F(UnwinderTest,speculative_frame_removed)734 TEST_F(UnwinderTest, speculative_frame_removed) {
735 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
736 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
737
738 // Fake as if code called a nullptr function.
739 regs_.set_pc(0x20000);
740 regs_.set_sp(0x10000);
741 ElfInterfaceFake::FakePushStepData(StepData(0, 0x10010, false));
742 regs_.FakeSetReturnAddress(0x12);
743 regs_.FakeSetReturnAddressValid(true);
744
745 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
746 unwinder.Unwind();
747 EXPECT_EQ(ERROR_INVALID_MAP, unwinder.LastErrorCode());
748 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
749
750 ASSERT_EQ(2U, unwinder.NumFrames());
751
752 auto* frame = &unwinder.frames()[0];
753 EXPECT_EQ(0U, frame->num);
754 EXPECT_EQ(0U, frame->rel_pc);
755 EXPECT_EQ(0x20000U, frame->pc);
756 EXPECT_EQ(0x10000U, frame->sp);
757 EXPECT_EQ("Frame0", frame->function_name);
758 EXPECT_EQ(0U, frame->function_offset);
759 EXPECT_EQ("/system/fake/libunwind.so", frame->map_name);
760 EXPECT_EQ(0U, frame->map_elf_start_offset);
761 EXPECT_EQ(0U, frame->map_exact_offset);
762 EXPECT_EQ(0x20000U, frame->map_start);
763 EXPECT_EQ(0x22000U, frame->map_end);
764 EXPECT_EQ(0U, frame->map_load_bias);
765 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
766
767 frame = &unwinder.frames()[1];
768 EXPECT_EQ(1U, frame->num);
769 EXPECT_EQ(0U, frame->rel_pc);
770 EXPECT_EQ(0U, frame->pc);
771 EXPECT_EQ(0x10010U, frame->sp);
772 EXPECT_EQ("", frame->function_name);
773 EXPECT_EQ(0U, frame->function_offset);
774 EXPECT_EQ("", frame->map_name);
775 EXPECT_EQ(0U, frame->map_elf_start_offset);
776 EXPECT_EQ(0U, frame->map_exact_offset);
777 EXPECT_EQ(0U, frame->map_start);
778 EXPECT_EQ(0U, frame->map_end);
779 EXPECT_EQ(0U, frame->map_load_bias);
780 EXPECT_EQ(0, frame->map_flags);
781 }
782
783 // Verify that a speculative frame is added and left if there are only
784 // two frames and the pc is in the middle nowhere.
TEST_F(UnwinderTest,speculative_frame_not_removed_pc_bad)785 TEST_F(UnwinderTest, speculative_frame_not_removed_pc_bad) {
786 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
787 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
788
789 // Fake as if code called a nullptr function.
790 regs_.set_pc(0);
791 regs_.set_sp(0x10000);
792 regs_.FakeSetReturnAddress(0x1202);
793 regs_.FakeSetReturnAddressValid(true);
794
795 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
796 unwinder.Unwind();
797 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
798 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
799
800 ASSERT_EQ(2U, unwinder.NumFrames());
801
802 auto* frame = &unwinder.frames()[0];
803 EXPECT_EQ(0U, frame->num);
804 EXPECT_EQ(0U, frame->rel_pc);
805 EXPECT_EQ(0U, frame->pc);
806 EXPECT_EQ(0x10000U, frame->sp);
807 EXPECT_EQ("", frame->function_name);
808 EXPECT_EQ(0U, frame->function_offset);
809 EXPECT_EQ("", frame->map_name);
810 EXPECT_EQ(0U, frame->map_elf_start_offset);
811 EXPECT_EQ(0U, frame->map_exact_offset);
812 EXPECT_EQ(0U, frame->map_start);
813 EXPECT_EQ(0U, frame->map_end);
814 EXPECT_EQ(0U, frame->map_load_bias);
815 EXPECT_EQ(0, frame->map_flags);
816
817 frame = &unwinder.frames()[1];
818 EXPECT_EQ(1U, frame->num);
819 EXPECT_EQ(0x200U, frame->rel_pc);
820 EXPECT_EQ(0x1200U, frame->pc);
821 EXPECT_EQ(0x10000U, frame->sp);
822 EXPECT_EQ("Frame0", frame->function_name);
823 EXPECT_EQ(0U, frame->function_offset);
824 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
825 EXPECT_EQ(0U, frame->map_elf_start_offset);
826 EXPECT_EQ(0U, frame->map_exact_offset);
827 EXPECT_EQ(0x1000U, frame->map_start);
828 EXPECT_EQ(0x8000U, frame->map_end);
829 EXPECT_EQ(0U, frame->map_load_bias);
830 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
831 }
832
833 // Verify that a speculative frame does not cause a crash when it wasn't
834 // really added due to a filter.
TEST_F(UnwinderTest,speculative_frame_check_with_no_frames)835 TEST_F(UnwinderTest, speculative_frame_check_with_no_frames) {
836 regs_.set_pc(0x23000);
837 regs_.set_sp(0x10000);
838 regs_.FakeSetReturnAddress(0x23100);
839 regs_.FakeSetReturnAddressValid(true);
840
841 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
842
843 std::vector<std::string> skip_names{"libanother.so"};
844 unwinder.Unwind(&skip_names);
845 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
846 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
847
848 ASSERT_EQ(0U, unwinder.NumFrames());
849 }
850
851 // Verify that an unwind stops when a frame is in given suffix.
TEST_F(UnwinderTest,map_ignore_suffixes)852 TEST_F(UnwinderTest, map_ignore_suffixes) {
853 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
854 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
855 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
856 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame3", 3));
857
858 // Fake as if code called a nullptr function.
859 regs_.set_pc(0x1000);
860 regs_.set_sp(0x10000);
861 ElfInterfaceFake::FakePushStepData(StepData(0x43402, 0x10010, false));
862 ElfInterfaceFake::FakePushStepData(StepData(0x53502, 0x10020, false));
863 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
864
865 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
866 std::vector<std::string> suffixes{"oat"};
867 unwinder.Unwind(nullptr, &suffixes);
868 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
869 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
870
871 ASSERT_EQ(2U, unwinder.NumFrames());
872 // Make sure the elf was not initialized.
873 MapInfo* map_info = maps_->Find(0x53000);
874 ASSERT_TRUE(map_info != nullptr);
875 EXPECT_TRUE(map_info->elf == nullptr);
876
877 auto* frame = &unwinder.frames()[0];
878 EXPECT_EQ(0U, frame->num);
879 EXPECT_EQ(0U, frame->rel_pc);
880 EXPECT_EQ(0x1000U, frame->pc);
881 EXPECT_EQ(0x10000U, frame->sp);
882 EXPECT_EQ("Frame0", frame->function_name);
883 EXPECT_EQ(0U, frame->function_offset);
884 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
885 EXPECT_EQ(0U, frame->map_elf_start_offset);
886 EXPECT_EQ(0U, frame->map_exact_offset);
887 EXPECT_EQ(0x1000U, frame->map_start);
888 EXPECT_EQ(0x8000U, frame->map_end);
889 EXPECT_EQ(0U, frame->map_load_bias);
890 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
891
892 frame = &unwinder.frames()[1];
893 EXPECT_EQ(1U, frame->num);
894 EXPECT_EQ(0x400U, frame->rel_pc);
895 EXPECT_EQ(0x43400U, frame->pc);
896 EXPECT_EQ(0x10010U, frame->sp);
897 EXPECT_EQ("Frame1", frame->function_name);
898 EXPECT_EQ(1U, frame->function_offset);
899 EXPECT_EQ("/fake/fake.apk!lib_fake.so", frame->map_name);
900 EXPECT_EQ(0x1d000U, frame->map_elf_start_offset);
901 EXPECT_EQ(0x1d000U, frame->map_exact_offset);
902 EXPECT_EQ(0x43000U, frame->map_start);
903 EXPECT_EQ(0x44000U, frame->map_end);
904 EXPECT_EQ(0U, frame->map_load_bias);
905 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
906 }
907
908 // Verify that an unwind stops when the sp and pc don't change.
TEST_F(UnwinderTest,sp_pc_do_not_change)909 TEST_F(UnwinderTest, sp_pc_do_not_change) {
910 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
911 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
912 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
913 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame3", 3));
914 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame4", 4));
915
916 regs_.set_pc(0x1000);
917 regs_.set_sp(0x10000);
918 ElfInterfaceFake::FakePushStepData(StepData(0x33402, 0x10010, false));
919 ElfInterfaceFake::FakePushStepData(StepData(0x33502, 0x10020, false));
920 ElfInterfaceFake::FakePushStepData(StepData(0x33502, 0x10020, false));
921 ElfInterfaceFake::FakePushStepData(StepData(0x33502, 0x10020, false));
922 ElfInterfaceFake::FakePushStepData(StepData(0x33502, 0x10020, false));
923 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
924
925 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
926 unwinder.Unwind();
927 EXPECT_EQ(ERROR_REPEATED_FRAME, unwinder.LastErrorCode());
928 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
929
930 ASSERT_EQ(3U, unwinder.NumFrames());
931
932 auto* frame = &unwinder.frames()[0];
933 EXPECT_EQ(0U, frame->num);
934 EXPECT_EQ(0U, frame->rel_pc);
935 EXPECT_EQ(0x1000U, frame->pc);
936 EXPECT_EQ(0x10000U, frame->sp);
937 EXPECT_EQ("Frame0", frame->function_name);
938 EXPECT_EQ(0U, frame->function_offset);
939 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
940 EXPECT_EQ(0U, frame->map_elf_start_offset);
941 EXPECT_EQ(0U, frame->map_exact_offset);
942 EXPECT_EQ(0x1000U, frame->map_start);
943 EXPECT_EQ(0x8000U, frame->map_end);
944 EXPECT_EQ(0U, frame->map_load_bias);
945 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
946
947 frame = &unwinder.frames()[1];
948 EXPECT_EQ(1U, frame->num);
949 EXPECT_EQ(0x400U, frame->rel_pc);
950 EXPECT_EQ(0x33400U, frame->pc);
951 EXPECT_EQ(0x10010U, frame->sp);
952 EXPECT_EQ("Frame1", frame->function_name);
953 EXPECT_EQ(1U, frame->function_offset);
954 EXPECT_EQ("/fake/compressed.so", frame->map_name);
955 EXPECT_EQ(0U, frame->map_elf_start_offset);
956 EXPECT_EQ(0U, frame->map_exact_offset);
957 EXPECT_EQ(0x33000U, frame->map_start);
958 EXPECT_EQ(0x34000U, frame->map_end);
959 EXPECT_EQ(0U, frame->map_load_bias);
960 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
961
962 frame = &unwinder.frames()[2];
963 EXPECT_EQ(2U, frame->num);
964 EXPECT_EQ(0x500U, frame->rel_pc);
965 EXPECT_EQ(0x33500U, frame->pc);
966 EXPECT_EQ(0x10020U, frame->sp);
967 EXPECT_EQ("Frame2", frame->function_name);
968 EXPECT_EQ(2U, frame->function_offset);
969 EXPECT_EQ("/fake/compressed.so", frame->map_name);
970 EXPECT_EQ(0U, frame->map_elf_start_offset);
971 EXPECT_EQ(0U, frame->map_exact_offset);
972 EXPECT_EQ(0x33000U, frame->map_start);
973 EXPECT_EQ(0x34000U, frame->map_end);
974 EXPECT_EQ(0U, frame->map_load_bias);
975 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
976 }
977
TEST_F(UnwinderTest,dex_pc_in_map)978 TEST_F(UnwinderTest, dex_pc_in_map) {
979 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
980 regs_.set_pc(0x1000);
981 regs_.set_sp(0x10000);
982 regs_.FakeSetDexPc(0xa3400);
983
984 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
985 unwinder.Unwind();
986 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
987 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
988
989 ASSERT_EQ(2U, unwinder.NumFrames());
990
991 auto* frame = &unwinder.frames()[0];
992 EXPECT_EQ(0U, frame->num);
993 EXPECT_EQ(0x400U, frame->rel_pc);
994 EXPECT_EQ(0xa3400U, frame->pc);
995 EXPECT_EQ(0x10000U, frame->sp);
996 EXPECT_EQ("", frame->function_name);
997 EXPECT_EQ(0U, frame->function_offset);
998 EXPECT_EQ("/fake/fake.vdex", frame->map_name);
999 EXPECT_EQ(0U, frame->map_elf_start_offset);
1000 EXPECT_EQ(0U, frame->map_exact_offset);
1001 EXPECT_EQ(0xa3000U, frame->map_start);
1002 EXPECT_EQ(0xa4000U, frame->map_end);
1003 EXPECT_EQ(0U, frame->map_load_bias);
1004 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags);
1005
1006 frame = &unwinder.frames()[1];
1007 EXPECT_EQ(1U, frame->num);
1008 EXPECT_EQ(0U, frame->rel_pc);
1009 EXPECT_EQ(0x1000U, frame->pc);
1010 EXPECT_EQ(0x10000U, frame->sp);
1011 EXPECT_EQ("Frame0", frame->function_name);
1012 EXPECT_EQ(0U, frame->function_offset);
1013 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
1014 EXPECT_EQ(0U, frame->map_elf_start_offset);
1015 EXPECT_EQ(0U, frame->map_exact_offset);
1016 EXPECT_EQ(0x1000U, frame->map_start);
1017 EXPECT_EQ(0x8000U, frame->map_end);
1018 EXPECT_EQ(0U, frame->map_load_bias);
1019 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
1020 }
1021
TEST_F(UnwinderTest,dex_pc_in_map_non_zero_offset)1022 TEST_F(UnwinderTest, dex_pc_in_map_non_zero_offset) {
1023 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1024 regs_.set_pc(0x1000);
1025 regs_.set_sp(0x10000);
1026 regs_.FakeSetDexPc(0xd0400);
1027
1028 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1029 unwinder.Unwind();
1030 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1031 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
1032
1033 ASSERT_EQ(2U, unwinder.NumFrames());
1034
1035 auto* frame = &unwinder.frames()[0];
1036 EXPECT_EQ(0U, frame->num);
1037 EXPECT_EQ(0x400U, frame->rel_pc);
1038 EXPECT_EQ(0xd0400U, frame->pc);
1039 EXPECT_EQ(0x10000U, frame->sp);
1040 EXPECT_EQ("", frame->function_name);
1041 EXPECT_EQ(0U, frame->function_offset);
1042 EXPECT_EQ("/fake/fake.apk", frame->map_name);
1043 EXPECT_EQ(0x1000U, frame->map_elf_start_offset);
1044 EXPECT_EQ(0x1000U, frame->map_exact_offset);
1045 EXPECT_EQ(0xd0000U, frame->map_start);
1046 EXPECT_EQ(0xd1000U, frame->map_end);
1047 EXPECT_EQ(0U, frame->map_load_bias);
1048 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags);
1049
1050 frame = &unwinder.frames()[1];
1051 EXPECT_EQ(1U, frame->num);
1052 EXPECT_EQ(0U, frame->rel_pc);
1053 EXPECT_EQ(0x1000U, frame->pc);
1054 EXPECT_EQ(0x10000U, frame->sp);
1055 EXPECT_EQ("Frame0", frame->function_name);
1056 EXPECT_EQ(0U, frame->function_offset);
1057 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
1058 EXPECT_EQ(0U, frame->map_elf_start_offset);
1059 EXPECT_EQ(0U, frame->map_exact_offset);
1060 EXPECT_EQ(0x1000U, frame->map_start);
1061 EXPECT_EQ(0x8000U, frame->map_end);
1062 EXPECT_EQ(0U, frame->map_load_bias);
1063 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
1064 }
1065
TEST_F(UnwinderTest,dex_pc_not_in_map)1066 TEST_F(UnwinderTest, dex_pc_not_in_map) {
1067 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1068 regs_.set_pc(0x1000);
1069 regs_.set_sp(0x10000);
1070 regs_.FakeSetDexPc(0x50000);
1071
1072 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1073 unwinder.Unwind();
1074 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1075 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
1076
1077 ASSERT_EQ(2U, unwinder.NumFrames());
1078
1079 auto* frame = &unwinder.frames()[0];
1080 EXPECT_EQ(0U, frame->num);
1081 EXPECT_EQ(0x50000U, frame->rel_pc);
1082 EXPECT_EQ(0x50000U, frame->pc);
1083 EXPECT_EQ(0x10000U, frame->sp);
1084 EXPECT_EQ("", frame->function_name);
1085 EXPECT_EQ(0U, frame->function_offset);
1086 EXPECT_EQ("", frame->map_name);
1087 EXPECT_EQ(0U, frame->map_elf_start_offset);
1088 EXPECT_EQ(0U, frame->map_exact_offset);
1089 EXPECT_EQ(0U, frame->map_start);
1090 EXPECT_EQ(0U, frame->map_end);
1091 EXPECT_EQ(0U, frame->map_load_bias);
1092 EXPECT_EQ(0, frame->map_flags);
1093
1094 frame = &unwinder.frames()[1];
1095 EXPECT_EQ(1U, frame->num);
1096 EXPECT_EQ(0U, frame->rel_pc);
1097 EXPECT_EQ(0x1000U, frame->pc);
1098 EXPECT_EQ(0x10000U, frame->sp);
1099 EXPECT_EQ("Frame0", frame->function_name);
1100 EXPECT_EQ(0U, frame->function_offset);
1101 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
1102 EXPECT_EQ(0U, frame->map_elf_start_offset);
1103 EXPECT_EQ(0U, frame->map_exact_offset);
1104 EXPECT_EQ(0x1000U, frame->map_start);
1105 EXPECT_EQ(0x8000U, frame->map_end);
1106 EXPECT_EQ(0U, frame->map_load_bias);
1107 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
1108 }
1109
TEST_F(UnwinderTest,dex_pc_multiple_frames)1110 TEST_F(UnwinderTest, dex_pc_multiple_frames) {
1111 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1112 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
1113 regs_.set_pc(0x1000);
1114 regs_.set_sp(0x10000);
1115 regs_.FakeSetDexPc(0xa3400);
1116 ElfInterfaceFake::FakePushStepData(StepData(0x33402, 0x10010, false));
1117 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
1118
1119 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1120 unwinder.Unwind();
1121 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1122 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
1123
1124 ASSERT_EQ(3U, unwinder.NumFrames());
1125
1126 auto* frame = &unwinder.frames()[0];
1127 EXPECT_EQ(0U, frame->num);
1128 EXPECT_EQ(0x400U, frame->rel_pc);
1129 EXPECT_EQ(0xa3400U, frame->pc);
1130 EXPECT_EQ(0x10000U, frame->sp);
1131 EXPECT_EQ("", frame->function_name);
1132 EXPECT_EQ(0U, frame->function_offset);
1133 EXPECT_EQ("/fake/fake.vdex", frame->map_name);
1134 EXPECT_EQ(0U, frame->map_elf_start_offset);
1135 EXPECT_EQ(0U, frame->map_exact_offset);
1136 EXPECT_EQ(0xa3000U, frame->map_start);
1137 EXPECT_EQ(0xa4000U, frame->map_end);
1138 EXPECT_EQ(0U, frame->map_load_bias);
1139 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags);
1140
1141 frame = &unwinder.frames()[1];
1142 EXPECT_EQ(1U, frame->num);
1143 EXPECT_EQ(0U, frame->rel_pc);
1144 EXPECT_EQ(0x1000U, frame->pc);
1145 EXPECT_EQ(0x10000U, frame->sp);
1146 EXPECT_EQ("Frame0", frame->function_name);
1147 EXPECT_EQ(0U, frame->function_offset);
1148 EXPECT_EQ("/system/fake/libc.so", frame->map_name);
1149 EXPECT_EQ(0U, frame->map_elf_start_offset);
1150 EXPECT_EQ(0U, frame->map_exact_offset);
1151 EXPECT_EQ(0x1000U, frame->map_start);
1152 EXPECT_EQ(0x8000U, frame->map_end);
1153 EXPECT_EQ(0U, frame->map_load_bias);
1154 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
1155
1156 frame = &unwinder.frames()[2];
1157 EXPECT_EQ(2U, frame->num);
1158 EXPECT_EQ(0x400U, frame->rel_pc);
1159 EXPECT_EQ(0x33400U, frame->pc);
1160 EXPECT_EQ(0x10010U, frame->sp);
1161 EXPECT_EQ("Frame1", frame->function_name);
1162 EXPECT_EQ(1U, frame->function_offset);
1163 EXPECT_EQ("/fake/compressed.so", frame->map_name);
1164 EXPECT_EQ(0U, frame->map_elf_start_offset);
1165 EXPECT_EQ(0U, frame->map_exact_offset);
1166 EXPECT_EQ(0x33000U, frame->map_start);
1167 EXPECT_EQ(0x34000U, frame->map_end);
1168 EXPECT_EQ(0U, frame->map_load_bias);
1169 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags);
1170 }
1171
TEST_F(UnwinderTest,dex_pc_max_frames)1172 TEST_F(UnwinderTest, dex_pc_max_frames) {
1173 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1174 regs_.set_pc(0x1000);
1175 regs_.set_sp(0x10000);
1176 regs_.FakeSetDexPc(0xa3400);
1177
1178 Unwinder unwinder(1, maps_.get(), ®s_, process_memory_);
1179 unwinder.Unwind();
1180 EXPECT_EQ(ERROR_MAX_FRAMES_EXCEEDED, unwinder.LastErrorCode());
1181 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
1182
1183 ASSERT_EQ(1U, unwinder.NumFrames());
1184
1185 auto* frame = &unwinder.frames()[0];
1186 EXPECT_EQ(0U, frame->num);
1187 EXPECT_EQ(0x400U, frame->rel_pc);
1188 EXPECT_EQ(0xa3400U, frame->pc);
1189 EXPECT_EQ(0x10000U, frame->sp);
1190 EXPECT_EQ("", frame->function_name);
1191 EXPECT_EQ(0U, frame->function_offset);
1192 EXPECT_EQ("/fake/fake.vdex", frame->map_name);
1193 EXPECT_EQ(0U, frame->map_elf_start_offset);
1194 EXPECT_EQ(0U, frame->map_exact_offset);
1195 EXPECT_EQ(0xa3000U, frame->map_start);
1196 EXPECT_EQ(0xa4000U, frame->map_end);
1197 EXPECT_EQ(0U, frame->map_load_bias);
1198 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags);
1199 }
1200
TEST_F(UnwinderTest,elf_from_memory_not_file)1201 TEST_F(UnwinderTest, elf_from_memory_not_file) {
1202 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1203
1204 regs_.set_pc(0xc0050);
1205 regs_.set_sp(0x10000);
1206 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
1207
1208 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1209 unwinder.Unwind();
1210 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1211 EXPECT_TRUE(unwinder.elf_from_memory_not_file());
1212
1213 ASSERT_EQ(1U, unwinder.NumFrames());
1214
1215 auto* frame = &unwinder.frames()[0];
1216 EXPECT_EQ(0U, frame->num);
1217 EXPECT_EQ(0x50U, frame->rel_pc);
1218 EXPECT_EQ(0xc0050U, frame->pc);
1219 EXPECT_EQ(0x10000U, frame->sp);
1220 EXPECT_EQ("Frame0", frame->function_name);
1221 EXPECT_EQ(0U, frame->function_offset);
1222 EXPECT_EQ("/fake/unreadable.so", frame->map_name);
1223 EXPECT_EQ(0U, frame->map_elf_start_offset);
1224 EXPECT_EQ(0U, frame->map_exact_offset);
1225 EXPECT_EQ(0xc0000U, frame->map_start);
1226 EXPECT_EQ(0xc1000U, frame->map_end);
1227 EXPECT_EQ(0U, frame->map_load_bias);
1228 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags);
1229 }
1230
TEST_F(UnwinderTest,elf_from_memory_but_no_valid_file_with_bracket)1231 TEST_F(UnwinderTest, elf_from_memory_but_no_valid_file_with_bracket) {
1232 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1233
1234 regs_.set_pc(0xc1050);
1235 regs_.set_sp(0x10000);
1236 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
1237
1238 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1239 unwinder.Unwind();
1240 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1241 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
1242
1243 ASSERT_EQ(1U, unwinder.NumFrames());
1244
1245 auto* frame = &unwinder.frames()[0];
1246 EXPECT_EQ(0U, frame->num);
1247 EXPECT_EQ(0x50U, frame->rel_pc);
1248 EXPECT_EQ(0xc1050U, frame->pc);
1249 EXPECT_EQ(0x10000U, frame->sp);
1250 EXPECT_EQ("Frame0", frame->function_name);
1251 EXPECT_EQ(0U, frame->function_offset);
1252 EXPECT_EQ("[vdso]", frame->map_name);
1253 EXPECT_EQ(0U, frame->map_elf_start_offset);
1254 EXPECT_EQ(0U, frame->map_exact_offset);
1255 EXPECT_EQ(0xc1000U, frame->map_start);
1256 EXPECT_EQ(0xc2000U, frame->map_end);
1257 EXPECT_EQ(0U, frame->map_load_bias);
1258 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags);
1259 }
1260
TEST_F(UnwinderTest,elf_from_memory_but_empty_filename)1261 TEST_F(UnwinderTest, elf_from_memory_but_empty_filename) {
1262 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1263
1264 regs_.set_pc(0xc2050);
1265 regs_.set_sp(0x10000);
1266 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
1267
1268 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1269 unwinder.Unwind();
1270 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1271 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
1272
1273 ASSERT_EQ(1U, unwinder.NumFrames());
1274
1275 auto* frame = &unwinder.frames()[0];
1276 EXPECT_EQ(0U, frame->num);
1277 EXPECT_EQ(0x50U, frame->rel_pc);
1278 EXPECT_EQ(0xc2050U, frame->pc);
1279 EXPECT_EQ(0x10000U, frame->sp);
1280 EXPECT_EQ("Frame0", frame->function_name);
1281 EXPECT_EQ(0U, frame->function_offset);
1282 EXPECT_EQ("", frame->map_name);
1283 EXPECT_EQ(0U, frame->map_elf_start_offset);
1284 EXPECT_EQ(0U, frame->map_exact_offset);
1285 EXPECT_EQ(0xc2000U, frame->map_start);
1286 EXPECT_EQ(0xc3000U, frame->map_end);
1287 EXPECT_EQ(0U, frame->map_load_bias);
1288 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags);
1289 }
1290
TEST_F(UnwinderTest,elf_from_memory_but_from_memfd)1291 TEST_F(UnwinderTest, elf_from_memory_but_from_memfd) {
1292 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1293
1294 regs_.set_pc(0xc3050);
1295 regs_.set_sp(0x10000);
1296 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
1297
1298 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1299 unwinder.Unwind();
1300 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1301 EXPECT_FALSE(unwinder.elf_from_memory_not_file());
1302
1303 ASSERT_EQ(1U, unwinder.NumFrames());
1304
1305 auto* frame = &unwinder.frames()[0];
1306 EXPECT_EQ(0U, frame->num);
1307 EXPECT_EQ(0x50U, frame->rel_pc);
1308 EXPECT_EQ(0xc3050U, frame->pc);
1309 EXPECT_EQ(0x10000U, frame->sp);
1310 EXPECT_EQ("Frame0", frame->function_name);
1311 EXPECT_EQ(0U, frame->function_offset);
1312 EXPECT_EQ("/memfd:/jit-cache", frame->map_name);
1313 EXPECT_EQ(0U, frame->map_elf_start_offset);
1314 EXPECT_EQ(0U, frame->map_exact_offset);
1315 EXPECT_EQ(0xc3000U, frame->map_start);
1316 EXPECT_EQ(0xc4000U, frame->map_end);
1317 EXPECT_EQ(0U, frame->map_load_bias);
1318 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags);
1319 }
1320
1321 // Verify format frame code.
TEST_F(UnwinderTest,format_frame)1322 TEST_F(UnwinderTest, format_frame) {
1323 RegsFake regs_arm(10);
1324 regs_arm.FakeSetArch(ARCH_ARM);
1325 Unwinder unwinder32(10, maps_.get(), ®s_arm, process_memory_);
1326
1327 RegsFake regs_arm64(10);
1328 regs_arm64.FakeSetArch(ARCH_ARM64);
1329 Unwinder unwinder64(10, maps_.get(), ®s_arm64, process_memory_);
1330
1331 FrameData frame;
1332 frame.num = 1;
1333 frame.rel_pc = 0x1000;
1334 frame.pc = 0x4000;
1335 frame.sp = 0x1000;
1336 frame.function_name = "function";
1337 frame.function_offset = 100;
1338 frame.map_name = "/fake/libfake.so";
1339 frame.map_elf_start_offset = 0x2000;
1340 frame.map_start = 0x3000;
1341 frame.map_end = 0x6000;
1342 frame.map_flags = PROT_READ;
1343
1344 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so (offset 0x2000) (function+100)",
1345 unwinder64.FormatFrame(frame));
1346 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (offset 0x2000) (function+100)",
1347 unwinder32.FormatFrame(frame));
1348
1349 frame.map_elf_start_offset = 0;
1350 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so (function+100)",
1351 unwinder64.FormatFrame(frame));
1352 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (function+100)", unwinder32.FormatFrame(frame));
1353
1354 frame.function_offset = 0;
1355 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so (function)",
1356 unwinder64.FormatFrame(frame));
1357 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (function)", unwinder32.FormatFrame(frame));
1358
1359 // Verify the function name is demangled.
1360 frame.function_name = "_ZN4funcEv";
1361 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so (func())", unwinder64.FormatFrame(frame));
1362 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (func())", unwinder32.FormatFrame(frame));
1363
1364 frame.function_name = "";
1365 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so", unwinder64.FormatFrame(frame));
1366 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so", unwinder32.FormatFrame(frame));
1367
1368 frame.map_name = "";
1369 EXPECT_EQ(" #01 pc 0000000000001000 <anonymous:3000>", unwinder64.FormatFrame(frame));
1370 EXPECT_EQ(" #01 pc 00001000 <anonymous:3000>", unwinder32.FormatFrame(frame));
1371
1372 frame.map_start = 0;
1373 frame.map_end = 0;
1374 EXPECT_EQ(" #01 pc 0000000000001000 <unknown>", unwinder64.FormatFrame(frame));
1375 EXPECT_EQ(" #01 pc 00001000 <unknown>", unwinder32.FormatFrame(frame));
1376 }
1377
TEST_F(UnwinderTest,format_frame_build_id)1378 TEST_F(UnwinderTest, format_frame_build_id) {
1379 RegsFake regs(10);
1380 regs.FakeSetArch(ARCH_ARM);
1381 Unwinder unwinder(10, maps_.get(), ®s, process_memory_);
1382
1383 FrameData frame;
1384 frame.num = 1;
1385 frame.rel_pc = 0x1000;
1386 frame.pc = 0x4000;
1387 frame.sp = 0x1000;
1388 frame.function_name = "function";
1389 frame.function_offset = 100;
1390 frame.map_name = "/fake/libfake.so";
1391 frame.map_elf_start_offset = 0;
1392 frame.map_start = 0x3000;
1393 frame.map_end = 0x6000;
1394 frame.map_flags = PROT_READ;
1395
1396 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (function+100)", unwinder.FormatFrame(frame));
1397 unwinder.SetDisplayBuildID(true);
1398 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (function+100) (BuildId: 46414b45)",
1399 unwinder.FormatFrame(frame));
1400 }
1401
ArchToString(ArchEnum arch)1402 static std::string ArchToString(ArchEnum arch) {
1403 if (arch == ARCH_ARM) {
1404 return "Arm";
1405 } else if (arch == ARCH_ARM64) {
1406 return "Arm64";
1407 } else if (arch == ARCH_X86) {
1408 return "X86";
1409 } else if (arch == ARCH_X86_64) {
1410 return "X86_64";
1411 } else {
1412 return "Unknown";
1413 }
1414 }
1415
1416 // Verify format frame code.
TEST_F(UnwinderTest,format_frame_by_arch)1417 TEST_F(UnwinderTest, format_frame_by_arch) {
1418 std::vector<Regs*> reg_list;
1419 RegsArm* arm = new RegsArm;
1420 arm->set_pc(0x2300);
1421 arm->set_sp(0x10000);
1422 reg_list.push_back(arm);
1423
1424 RegsArm64* arm64 = new RegsArm64;
1425 arm64->set_pc(0x2300);
1426 arm64->set_sp(0x10000);
1427 reg_list.push_back(arm64);
1428
1429 RegsX86* x86 = new RegsX86;
1430 x86->set_pc(0x2300);
1431 x86->set_sp(0x10000);
1432 reg_list.push_back(x86);
1433
1434 RegsX86_64* x86_64 = new RegsX86_64;
1435 x86_64->set_pc(0x2300);
1436 x86_64->set_sp(0x10000);
1437 reg_list.push_back(x86_64);
1438
1439 RegsMips* mips = new RegsMips;
1440 mips->set_pc(0x2300);
1441 mips->set_sp(0x10000);
1442 reg_list.push_back(mips);
1443
1444 RegsMips64* mips64 = new RegsMips64;
1445 mips64->set_pc(0x2300);
1446 mips64->set_sp(0x10000);
1447 reg_list.push_back(mips64);
1448
1449 for (auto regs : reg_list) {
1450 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 10));
1451
1452 Unwinder unwinder(64, maps_.get(), regs, process_memory_);
1453 unwinder.Unwind();
1454
1455 ASSERT_EQ(1U, unwinder.NumFrames());
1456 std::string expected;
1457 switch (regs->Arch()) {
1458 case ARCH_ARM:
1459 case ARCH_X86:
1460 case ARCH_MIPS:
1461 expected = " #00 pc 00001300 /system/fake/libc.so (Frame0+10)";
1462 break;
1463 case ARCH_ARM64:
1464 case ARCH_X86_64:
1465 case ARCH_MIPS64:
1466 expected = " #00 pc 0000000000001300 /system/fake/libc.so (Frame0+10)";
1467 break;
1468 default:
1469 expected = "";
1470 }
1471 EXPECT_EQ(expected, unwinder.FormatFrame(0))
1472 << "Mismatch of frame format for regs arch " << ArchToString(regs->Arch());
1473 delete regs;
1474 }
1475 }
1476
1477 } // namespace unwindstack
1478