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 <android-base/silent_death_test.h>
28 #include <unwindstack/Elf.h>
29 #include <unwindstack/Maps.h>
30 #include <unwindstack/Memory.h>
31 #include <unwindstack/Regs.h>
32 #include <unwindstack/RegsArm.h>
33 #include <unwindstack/RegsArm64.h>
34 #include <unwindstack/RegsRiscv64.h>
35 #include <unwindstack/RegsX86.h>
36 #include <unwindstack/RegsX86_64.h>
37 #include <unwindstack/Unwinder.h>
38
39 #include "ElfFake.h"
40 #include "ElfTestUtils.h"
41 #include "utils/MemoryFake.h"
42 #include "utils/RegsFake.h"
43
44 namespace unwindstack {
45
46 class UnwinderTest : public ::testing::Test {
47 protected:
AddMapInfo(uint64_t start,uint64_t end,uint64_t offset,uint64_t flags,const char * name,Elf * elf=nullptr)48 static MapInfo* AddMapInfo(uint64_t start, uint64_t end, uint64_t offset, uint64_t flags,
49 const char* name, Elf* elf = nullptr) {
50 std::string str_name(name);
51 maps_->Add(start, end, offset, flags, name);
52 MapInfo* map_info = maps_->Find(start).get();
53 if (elf != nullptr) {
54 map_info->set_elf(elf);
55 }
56 return map_info;
57 }
58
SetUpTestSuite()59 static void SetUpTestSuite() {
60 maps_.reset(new Maps);
61
62 memory_ = new MemoryFake;
63 process_memory_.reset(memory_);
64
65 ElfFake* elf;
66 ElfInterfaceFake* interface;
67 MapInfo* map_info;
68
69 std::shared_ptr<Memory> empty;
70 std::shared_ptr<Memory> elf_memory(new MemoryFake);
71
72 elf = new ElfFake(elf_memory);
73 interface = new ElfInterfaceFake(empty);
74 interface->FakeSetBuildID("FAKE");
75 elf->FakeSetInterface(interface);
76 AddMapInfo(0x1000, 0x8000, 0, PROT_READ | PROT_WRITE, "/system/fake/libc.so", elf);
77
78 AddMapInfo(0x10000, 0x12000, 0, PROT_READ | PROT_WRITE, "[stack]");
79
80 AddMapInfo(0x13000, 0x15000, 0, PROT_READ | PROT_WRITE | MAPS_FLAGS_DEVICE_MAP,
81 "/dev/fake_device");
82
83 elf = new ElfFake(elf_memory);
84 elf->FakeSetInterface(new ElfInterfaceFake(empty));
85 AddMapInfo(0x20000, 0x22000, 0, PROT_READ | PROT_WRITE, "/system/fake/libunwind.so", elf);
86
87 elf = new ElfFake(elf_memory);
88 elf->FakeSetInterface(new ElfInterfaceFake(empty));
89 AddMapInfo(0x23000, 0x24000, 0, PROT_READ | PROT_WRITE, "/fake/libanother.so", elf);
90
91 elf = new ElfFake(elf_memory);
92 elf->FakeSetInterface(new ElfInterfaceFake(empty));
93 AddMapInfo(0x33000, 0x34000, 0, PROT_READ | PROT_WRITE, "/fake/compressed.so", elf);
94
95 elf = new ElfFake(elf_memory);
96 interface = new ElfInterfaceFake(empty);
97 interface->FakeSetSoname("lib_fake.so");
98 elf->FakeSetInterface(interface);
99 map_info = AddMapInfo(0x43000, 0x44000, 0x1d000, PROT_READ | PROT_WRITE, "/fake/fake.apk", elf);
100 map_info->set_elf_start_offset(0x1d000);
101
102 AddMapInfo(0x53000, 0x54000, 0, PROT_READ | PROT_WRITE, "/fake/fake.oat");
103
104 AddMapInfo(0xa3000, 0xa4000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "/fake/fake.vdex");
105
106 elf = new ElfFake(elf_memory);
107 elf->FakeSetInterface(new ElfInterfaceFake(empty));
108 elf->FakeSetLoadBias(0x5000);
109 AddMapInfo(0xa5000, 0xa6000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "/fake/fake_load_bias.so",
110 elf);
111
112 elf = new ElfFake(elf_memory);
113 elf->FakeSetInterface(new ElfInterfaceFake(empty));
114 map_info = AddMapInfo(0xa7000, 0xa8000, 0, PROT_READ | PROT_WRITE | PROT_EXEC,
115 "/fake/fake_offset.oat", elf);
116 map_info->set_elf_offset(0x8000);
117
118 AddMapInfo(0xa8000, 0xa9000, 0x1000, PROT_READ | PROT_WRITE | PROT_EXEC, "/fake/fake_vdex.apk");
119
120 elf = new ElfFake(elf_memory);
121 elf->FakeSetInterface(new ElfInterfaceFake(empty));
122 map_info = AddMapInfo(0xc0000, 0xc1000, 0, PROT_READ | PROT_WRITE | PROT_EXEC,
123 "/fake/unreadable.so", elf);
124 map_info->set_memory_backed_elf(true);
125
126 elf = new ElfFake(elf_memory);
127 elf->FakeSetInterface(new ElfInterfaceFake(empty));
128 map_info = AddMapInfo(0xc1000, 0xc2000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "[vdso]", elf);
129 map_info->set_memory_backed_elf(true);
130
131 elf = new ElfFake(elf_memory);
132 elf->FakeSetInterface(new ElfInterfaceFake(empty));
133 map_info = AddMapInfo(0xc2000, 0xc3000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "", elf);
134 map_info->set_memory_backed_elf(true);
135
136 elf = new ElfFake(elf_memory);
137 elf->FakeSetInterface(new ElfInterfaceFake(empty));
138 map_info = AddMapInfo(0xc3000, 0xc4000, 0, PROT_READ | PROT_WRITE | PROT_EXEC,
139 "/memfd:/jit-cache", elf);
140 map_info->set_memory_backed_elf(true);
141
142 map_info =
143 AddMapInfo(0xd0000, 0xd1000, 0x1000, PROT_READ | PROT_WRITE | PROT_EXEC, "/fake/fake.apk");
144 map_info->set_elf_start_offset(0x1000);
145
146 elf = new ElfFake(elf_memory);
147 interface = new ElfInterfaceFake(empty);
148 elf->FakeSetInterface(interface);
149 interface->FakeSetGlobalVariable("__dex_debug_descriptor", 0x1800);
150 interface->FakeSetGlobalVariable("__jit_debug_descriptor", 0x1900);
151 interface->FakeSetDataOffset(0x1000);
152 interface->FakeSetDataVaddrStart(0x1000);
153 interface->FakeSetDataVaddrEnd(0x8000);
154 AddMapInfo(0xf0000, 0xf1000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "/fake/global.so", elf);
155 AddMapInfo(0xf1000, 0xf9000, 0x1000, PROT_READ | PROT_WRITE, "/fake/global.so");
156 // dex debug data
157 memory_->SetData32(0xf180c, 0xf3000);
158 memory_->SetData32(0xf3000, 0xf4000);
159 memory_->SetData32(0xf3004, 0xf4000);
160 memory_->SetData32(0xf3008, 0xf5000);
161 // jit debug data
162 memory_->SetData32(0xf1900, 1);
163 memory_->SetData32(0xf1904, 0);
164 memory_->SetData32(0xf1908, 0xf6000);
165 memory_->SetData32(0xf190c, 0xf6000);
166 memory_->SetData32(0xf6000, 0);
167 memory_->SetData32(0xf6004, 0);
168 memory_->SetData32(0xf6008, 0xf7000);
169 memory_->SetData32(0xf600c, 0);
170 memory_->SetData64(0xf6010, 0x1000);
171
172 elf = new ElfFake(elf_memory);
173 elf->FakeSetValid(false);
174 elf->FakeSetLoadBias(0x300);
175 map_info = AddMapInfo(0x100000, 0x101000, 0x1000, PROT_READ | PROT_WRITE | PROT_EXEC,
176 "/fake/jit.so", elf);
177 map_info->set_elf_start_offset(0x100);
178 map_info->set_offset(0x200);
179 }
180
SetUp()181 void SetUp() override {
182 ElfInterfaceFake::FakeClear();
183 regs_.FakeSetArch(ARCH_ARM);
184 regs_.FakeSetReturnAddressValid(false);
185 }
186
187 static std::unique_ptr<Maps> maps_;
188 static RegsFake regs_;
189 static MemoryFake* memory_;
190 static std::shared_ptr<Memory> process_memory_;
191 };
192
193 std::unique_ptr<Maps> UnwinderTest::maps_;
194 RegsFake UnwinderTest::regs_(5);
195 MemoryFake* UnwinderTest::memory_;
196 std::shared_ptr<Memory> UnwinderTest::process_memory_(nullptr);
197
TEST_F(UnwinderTest,multiple_frames)198 TEST_F(UnwinderTest, multiple_frames) {
199 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
200 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
201 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
202
203 regs_.set_pc(0x1000);
204 regs_.set_sp(0x10000);
205 ElfInterfaceFake::FakePushStepData(StepData(0x1104, 0x10010, false));
206 ElfInterfaceFake::FakePushStepData(StepData(0x1204, 0x10020, false));
207 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
208
209 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
210 unwinder.Unwind();
211 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
212 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
213
214 ASSERT_EQ(3U, unwinder.NumFrames());
215
216 auto* frame = &unwinder.frames()[0];
217 EXPECT_EQ(0U, frame->num);
218 EXPECT_EQ(0U, frame->rel_pc);
219 EXPECT_EQ(0x1000U, frame->pc);
220 EXPECT_EQ(0x10000U, frame->sp);
221 EXPECT_EQ("Frame0", frame->function_name);
222 EXPECT_EQ(0U, frame->function_offset);
223 ASSERT_TRUE(frame->map_info != nullptr);
224 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
225 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
226 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
227 EXPECT_EQ(0U, frame->map_info->offset());
228 EXPECT_EQ(0x1000U, frame->map_info->start());
229 EXPECT_EQ(0x8000U, frame->map_info->end());
230 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
231 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
232
233 frame = &unwinder.frames()[1];
234 EXPECT_EQ(1U, frame->num);
235 EXPECT_EQ(0x100U, frame->rel_pc);
236 EXPECT_EQ(0x1100U, frame->pc);
237 EXPECT_EQ(0x10010U, frame->sp);
238 EXPECT_EQ("Frame1", frame->function_name);
239 EXPECT_EQ(1U, frame->function_offset);
240 ASSERT_TRUE(frame->map_info != nullptr);
241 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
242 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
243 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
244 EXPECT_EQ(0U, frame->map_info->offset());
245 EXPECT_EQ(0x1000U, frame->map_info->start());
246 EXPECT_EQ(0x8000U, frame->map_info->end());
247 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
248 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
249
250 frame = &unwinder.frames()[2];
251 EXPECT_EQ(2U, frame->num);
252 EXPECT_EQ(0x200U, frame->rel_pc);
253 EXPECT_EQ(0x1200U, frame->pc);
254 EXPECT_EQ(0x10020U, frame->sp);
255 EXPECT_EQ("Frame2", frame->function_name);
256 EXPECT_EQ(2U, frame->function_offset);
257 ASSERT_TRUE(frame->map_info != nullptr);
258 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
259 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
260 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
261 EXPECT_EQ(0U, frame->map_info->offset());
262 EXPECT_EQ(0x1000U, frame->map_info->start());
263 EXPECT_EQ(0x8000U, frame->map_info->end());
264 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
265 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
266 }
267
TEST_F(UnwinderTest,multiple_frames_dont_resolve_names)268 TEST_F(UnwinderTest, multiple_frames_dont_resolve_names) {
269 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
270 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
271 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
272
273 regs_.set_pc(0x1000);
274 regs_.set_sp(0x10000);
275 ElfInterfaceFake::FakePushStepData(StepData(0x1104, 0x10010, false));
276 ElfInterfaceFake::FakePushStepData(StepData(0x1204, 0x10020, false));
277 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
278
279 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
280 unwinder.SetResolveNames(false);
281 unwinder.Unwind();
282 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
283 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
284
285 ASSERT_EQ(3U, unwinder.NumFrames());
286
287 auto* frame = &unwinder.frames()[0];
288 EXPECT_EQ(0U, frame->num);
289 EXPECT_EQ(0U, frame->rel_pc);
290 EXPECT_EQ(0x1000U, frame->pc);
291 EXPECT_EQ(0x10000U, frame->sp);
292 EXPECT_EQ("", frame->function_name);
293 EXPECT_EQ(0U, frame->function_offset);
294 ASSERT_TRUE(frame->map_info != nullptr);
295 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
296 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
297 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
298 EXPECT_EQ(0U, frame->map_info->offset());
299 EXPECT_EQ(0x1000U, frame->map_info->start());
300 EXPECT_EQ(0x8000U, frame->map_info->end());
301 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
302 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
303
304 frame = &unwinder.frames()[1];
305 EXPECT_EQ(1U, frame->num);
306 EXPECT_EQ(0x100U, frame->rel_pc);
307 EXPECT_EQ(0x1100U, frame->pc);
308 EXPECT_EQ(0x10010U, frame->sp);
309 EXPECT_EQ("", frame->function_name);
310 EXPECT_EQ(0U, frame->function_offset);
311 ASSERT_TRUE(frame->map_info != nullptr);
312 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
313 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
314 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
315 EXPECT_EQ(0U, frame->map_info->offset());
316 EXPECT_EQ(0x1000U, frame->map_info->start());
317 EXPECT_EQ(0x8000U, frame->map_info->end());
318 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
319 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
320
321 frame = &unwinder.frames()[2];
322 EXPECT_EQ(2U, frame->num);
323 EXPECT_EQ(0x200U, frame->rel_pc);
324 EXPECT_EQ(0x1200U, frame->pc);
325 EXPECT_EQ(0x10020U, frame->sp);
326 EXPECT_EQ("", frame->function_name);
327 EXPECT_EQ(0U, frame->function_offset);
328 ASSERT_TRUE(frame->map_info != nullptr);
329 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
330 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
331 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
332 EXPECT_EQ(0U, frame->map_info->offset());
333 EXPECT_EQ(0x1000U, frame->map_info->start());
334 EXPECT_EQ(0x8000U, frame->map_info->end());
335 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
336 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
337 }
338
TEST_F(UnwinderTest,non_zero_load_bias)339 TEST_F(UnwinderTest, non_zero_load_bias) {
340 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
341
342 regs_.set_pc(0xa5500);
343 regs_.set_sp(0x10000);
344 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
345
346 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
347 unwinder.Unwind();
348 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
349 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
350
351 ASSERT_EQ(1U, unwinder.NumFrames());
352
353 auto* frame = &unwinder.frames()[0];
354 EXPECT_EQ(0U, frame->num);
355 EXPECT_EQ(0x5500U, frame->rel_pc);
356 EXPECT_EQ(0xa5500U, frame->pc);
357 EXPECT_EQ(0x10000U, frame->sp);
358 EXPECT_EQ("Frame0", frame->function_name);
359 EXPECT_EQ(0U, frame->function_offset);
360 ASSERT_TRUE(frame->map_info != nullptr);
361 EXPECT_EQ("/fake/fake_load_bias.so", frame->map_info->name());
362 EXPECT_EQ("/fake/fake_load_bias.so", frame->map_info->GetFullName());
363 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
364 EXPECT_EQ(0U, frame->map_info->offset());
365 EXPECT_EQ(0xa5000U, frame->map_info->start());
366 EXPECT_EQ(0xa6000U, frame->map_info->end());
367 EXPECT_EQ(0x5000U, frame->map_info->GetLoadBias());
368 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_info->flags());
369 }
370
TEST_F(UnwinderTest,non_zero_elf_offset)371 TEST_F(UnwinderTest, non_zero_elf_offset) {
372 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
373
374 regs_.set_pc(0xa7500);
375 regs_.set_sp(0x10000);
376 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
377
378 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
379 unwinder.Unwind();
380 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
381 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
382
383 ASSERT_EQ(1U, unwinder.NumFrames());
384
385 auto* frame = &unwinder.frames()[0];
386 EXPECT_EQ(0U, frame->num);
387 EXPECT_EQ(0x8500U, frame->rel_pc);
388 EXPECT_EQ(0xa7500U, frame->pc);
389 EXPECT_EQ(0x10000U, frame->sp);
390 EXPECT_EQ("Frame0", frame->function_name);
391 EXPECT_EQ(0U, frame->function_offset);
392 ASSERT_TRUE(frame->map_info != nullptr);
393 EXPECT_EQ("/fake/fake_offset.oat", frame->map_info->name());
394 EXPECT_EQ("/fake/fake_offset.oat", frame->map_info->GetFullName());
395 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
396 EXPECT_EQ(0U, frame->map_info->offset());
397 EXPECT_EQ(0xa7000U, frame->map_info->start());
398 EXPECT_EQ(0xa8000U, frame->map_info->end());
399 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
400 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_info->flags());
401 }
402
TEST_F(UnwinderTest,non_zero_map_offset)403 TEST_F(UnwinderTest, non_zero_map_offset) {
404 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
405
406 regs_.set_pc(0x43000);
407 regs_.set_sp(0x10000);
408 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
409
410 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
411 unwinder.Unwind();
412 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
413 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
414
415 ASSERT_EQ(1U, unwinder.NumFrames());
416
417 auto* frame = &unwinder.frames()[0];
418 EXPECT_EQ(0U, frame->num);
419 EXPECT_EQ(0U, frame->rel_pc);
420 EXPECT_EQ(0x43000U, frame->pc);
421 EXPECT_EQ(0x10000U, frame->sp);
422 EXPECT_EQ("Frame0", frame->function_name);
423 EXPECT_EQ(0U, frame->function_offset);
424 ASSERT_TRUE(frame->map_info != nullptr);
425 EXPECT_EQ("/fake/fake.apk", frame->map_info->name());
426 EXPECT_EQ("/fake/fake.apk!lib_fake.so", frame->map_info->GetFullName());
427 EXPECT_EQ(0x1d000U, frame->map_info->elf_start_offset());
428 EXPECT_EQ(0x1d000U, frame->map_info->offset());
429 EXPECT_EQ(0x43000U, frame->map_info->start());
430 EXPECT_EQ(0x44000U, frame->map_info->end());
431 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
432 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
433 }
434
435 // Verify that no attempt to continue after the step indicates it is done.
TEST_F(UnwinderTest,no_frames_after_finished)436 TEST_F(UnwinderTest, no_frames_after_finished) {
437 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
438 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
439 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
440 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame3", 3));
441 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame4", 4));
442
443 regs_.set_pc(0x1000);
444 regs_.set_sp(0x10000);
445 ElfInterfaceFake::FakePushStepData(StepData(0x1000, 0x10000, true));
446 ElfInterfaceFake::FakePushStepData(StepData(0x1102, 0x10010, false));
447 ElfInterfaceFake::FakePushStepData(StepData(0x1202, 0x10020, false));
448
449 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
450 unwinder.Unwind();
451 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
452 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
453
454 ASSERT_EQ(1U, unwinder.NumFrames());
455
456 auto* frame = &unwinder.frames()[0];
457 EXPECT_EQ(0U, frame->num);
458 EXPECT_EQ(0U, frame->rel_pc);
459 EXPECT_EQ(0x1000U, frame->pc);
460 EXPECT_EQ(0x10000U, frame->sp);
461 EXPECT_EQ("Frame0", frame->function_name);
462 EXPECT_EQ(0U, frame->function_offset);
463 ASSERT_TRUE(frame->map_info != nullptr);
464 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
465 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
466 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
467 EXPECT_EQ(0U, frame->map_info->offset());
468 EXPECT_EQ(0x1000U, frame->map_info->start());
469 EXPECT_EQ(0x8000U, frame->map_info->end());
470 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
471 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
472 }
473
474 // Verify the maximum frames to save.
TEST_F(UnwinderTest,max_frames)475 TEST_F(UnwinderTest, max_frames) {
476 for (size_t i = 0; i < 30; i++) {
477 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame" + std::to_string(i), i));
478 ElfInterfaceFake::FakePushStepData(StepData(0x1104 + i * 0x100, 0x10010 + i * 0x10, false));
479 }
480
481 regs_.set_pc(0x1000);
482 regs_.set_sp(0x10000);
483
484 Unwinder unwinder(20, maps_.get(), ®s_, process_memory_);
485 unwinder.Unwind();
486 EXPECT_EQ(ERROR_MAX_FRAMES_EXCEEDED, unwinder.LastErrorCode());
487 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
488
489 ASSERT_EQ(20U, unwinder.NumFrames());
490
491 for (size_t i = 0; i < 20; i++) {
492 auto* frame = &unwinder.frames()[i];
493 EXPECT_EQ(i, frame->num);
494 SCOPED_TRACE(testing::Message() << "Failed at frame " << i);
495 EXPECT_EQ(i * 0x100, frame->rel_pc);
496 EXPECT_EQ(0x1000 + i * 0x100, frame->pc);
497 EXPECT_EQ(0x10000 + 0x10 * i, frame->sp);
498 EXPECT_EQ("Frame" + std::to_string(i), frame->function_name);
499 EXPECT_EQ(i, frame->function_offset);
500 ASSERT_TRUE(frame->map_info != nullptr);
501 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
502 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
503 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
504 EXPECT_EQ(0U, frame->map_info->offset());
505 EXPECT_EQ(0x1000U, frame->map_info->start());
506 EXPECT_EQ(0x8000U, frame->map_info->end());
507 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
508 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
509 }
510 }
511
512 // Verify that initial map names frames are removed.
TEST_F(UnwinderTest,verify_frames_skipped)513 TEST_F(UnwinderTest, verify_frames_skipped) {
514 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
515 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
516 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
517
518 regs_.set_pc(0x20000);
519 regs_.set_sp(0x10000);
520 ElfInterfaceFake::FakePushStepData(StepData(0x23004, 0x10010, false));
521 ElfInterfaceFake::FakePushStepData(StepData(0x23104, 0x10020, false));
522 ElfInterfaceFake::FakePushStepData(StepData(0x20004, 0x10030, false));
523 ElfInterfaceFake::FakePushStepData(StepData(0x21004, 0x10040, false));
524 ElfInterfaceFake::FakePushStepData(StepData(0x1002, 0x10050, false));
525 ElfInterfaceFake::FakePushStepData(StepData(0x21004, 0x10060, false));
526 ElfInterfaceFake::FakePushStepData(StepData(0x23002, 0x10070, false));
527 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
528
529 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
530 std::vector<std::string> skip_libs{"libunwind.so", "libanother.so"};
531 unwinder.Unwind(&skip_libs);
532 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
533 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
534
535 ASSERT_EQ(3U, unwinder.NumFrames());
536
537 auto* frame = &unwinder.frames()[0];
538 EXPECT_EQ(0U, frame->num);
539 EXPECT_EQ(0U, frame->rel_pc);
540 EXPECT_EQ(0x1000U, frame->pc);
541 EXPECT_EQ(0x10050U, frame->sp);
542 EXPECT_EQ("Frame0", frame->function_name);
543 EXPECT_EQ(0U, frame->function_offset);
544 ASSERT_TRUE(frame->map_info != nullptr);
545 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
546 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
547 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
548 EXPECT_EQ(0U, frame->map_info->offset());
549 EXPECT_EQ(0x1000U, frame->map_info->start());
550 EXPECT_EQ(0x8000U, frame->map_info->end());
551 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
552 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
553
554 frame = &unwinder.frames()[1];
555 EXPECT_EQ(1U, frame->num);
556 EXPECT_EQ(0x1000U, frame->rel_pc);
557 EXPECT_EQ(0x21000U, frame->pc);
558 EXPECT_EQ(0x10060U, frame->sp);
559 EXPECT_EQ("Frame1", frame->function_name);
560 EXPECT_EQ(1U, frame->function_offset);
561 ASSERT_TRUE(frame->map_info != nullptr);
562 EXPECT_EQ("/system/fake/libunwind.so", frame->map_info->name());
563 EXPECT_EQ("/system/fake/libunwind.so", frame->map_info->GetFullName());
564 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
565 EXPECT_EQ(0U, frame->map_info->offset());
566 EXPECT_EQ(0x20000U, frame->map_info->start());
567 EXPECT_EQ(0x22000U, frame->map_info->end());
568 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
569 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
570
571 frame = &unwinder.frames()[2];
572 EXPECT_EQ(2U, frame->num);
573 EXPECT_EQ(0U, frame->rel_pc);
574 EXPECT_EQ(0x23000U, frame->pc);
575 EXPECT_EQ(0x10070U, frame->sp);
576 EXPECT_EQ("Frame2", frame->function_name);
577 EXPECT_EQ(2U, frame->function_offset);
578 ASSERT_TRUE(frame->map_info != nullptr);
579 EXPECT_EQ("/fake/libanother.so", frame->map_info->name());
580 EXPECT_EQ("/fake/libanother.so", frame->map_info->GetFullName());
581 EXPECT_EQ(0U, frame->map_info->offset());
582 EXPECT_EQ(0x23000U, frame->map_info->start());
583 EXPECT_EQ(0x24000U, frame->map_info->end());
584 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
585 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
586 }
587
588 // Verify SP in a non-existant map is okay.
TEST_F(UnwinderTest,sp_not_in_map)589 TEST_F(UnwinderTest, sp_not_in_map) {
590 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
591 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
592
593 regs_.set_pc(0x1000);
594 regs_.set_sp(0x63000);
595 ElfInterfaceFake::FakePushStepData(StepData(0x21004, 0x50020, false));
596 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
597
598 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
599 unwinder.Unwind();
600 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
601 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
602
603 ASSERT_EQ(2U, unwinder.NumFrames());
604
605 auto* frame = &unwinder.frames()[0];
606 EXPECT_EQ(0U, frame->num);
607 EXPECT_EQ(0U, frame->rel_pc);
608 EXPECT_EQ(0x1000U, frame->pc);
609 EXPECT_EQ(0x63000U, frame->sp);
610 EXPECT_EQ("Frame0", frame->function_name);
611 EXPECT_EQ(0U, frame->function_offset);
612 ASSERT_TRUE(frame->map_info != nullptr);
613 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
614 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
615 EXPECT_EQ(0U, frame->map_info->offset());
616 EXPECT_EQ(0x1000U, frame->map_info->start());
617 EXPECT_EQ(0x8000U, frame->map_info->end());
618 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
619 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
620
621 frame = &unwinder.frames()[1];
622 EXPECT_EQ(1U, frame->num);
623 EXPECT_EQ(0x1000U, frame->rel_pc);
624 EXPECT_EQ(0x21000U, frame->pc);
625 EXPECT_EQ(0x50020U, frame->sp);
626 EXPECT_EQ("Frame1", frame->function_name);
627 EXPECT_EQ(1U, frame->function_offset);
628 ASSERT_TRUE(frame->map_info != nullptr);
629 EXPECT_EQ("/system/fake/libunwind.so", frame->map_info->name());
630 EXPECT_EQ("/system/fake/libunwind.so", frame->map_info->GetFullName());
631 EXPECT_EQ(0U, frame->map_info->offset());
632 EXPECT_EQ(0x20000U, frame->map_info->start());
633 EXPECT_EQ(0x22000U, frame->map_info->end());
634 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
635 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
636 }
637
638 // Verify PC in a device stops the unwind.
TEST_F(UnwinderTest,pc_in_device_stops_unwind)639 TEST_F(UnwinderTest, pc_in_device_stops_unwind) {
640 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
641 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
642 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
643
644 regs_.set_pc(0x13000);
645 regs_.set_sp(0x10000);
646 ElfInterfaceFake::FakePushStepData(StepData(0x23002, 0x10010, false));
647 ElfInterfaceFake::FakePushStepData(StepData(0x23102, 0x10020, false));
648 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
649
650 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
651 unwinder.Unwind();
652 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
653 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
654
655 ASSERT_EQ(1U, unwinder.NumFrames());
656 }
657
658 // Verify SP in a device stops the unwind.
TEST_F(UnwinderTest,sp_in_device_stops_unwind)659 TEST_F(UnwinderTest, sp_in_device_stops_unwind) {
660 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
661 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
662 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
663
664 regs_.set_pc(0x1000);
665 regs_.set_sp(0x13000);
666 ElfInterfaceFake::FakePushStepData(StepData(0x23002, 0x10010, false));
667 ElfInterfaceFake::FakePushStepData(StepData(0x23102, 0x10020, false));
668 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
669
670 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
671 unwinder.Unwind();
672 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
673 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
674
675 ASSERT_EQ(1U, unwinder.NumFrames());
676 }
677
678 // Verify a no map info frame gets a frame.
TEST_F(UnwinderTest,pc_without_map)679 TEST_F(UnwinderTest, pc_without_map) {
680 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
681
682 regs_.set_pc(0x41000);
683 regs_.set_sp(0x13000);
684
685 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
686 unwinder.Unwind();
687 EXPECT_EQ(ERROR_INVALID_MAP, unwinder.LastErrorCode());
688 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
689
690 ASSERT_EQ(1U, unwinder.NumFrames());
691
692 auto* frame = &unwinder.frames()[0];
693 EXPECT_EQ(0U, frame->num);
694 EXPECT_EQ(0x41000U, frame->rel_pc);
695 EXPECT_EQ(0x41000U, frame->pc);
696 EXPECT_EQ(0x13000U, frame->sp);
697 EXPECT_EQ("", frame->function_name);
698 EXPECT_EQ(0U, frame->function_offset);
699 ASSERT_TRUE(frame->map_info == nullptr);
700 }
701
702 // Verify that a speculative frame is added.
TEST_F(UnwinderTest,speculative_frame)703 TEST_F(UnwinderTest, speculative_frame) {
704 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
705 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
706
707 // Fake as if code called a nullptr function.
708 regs_.set_pc(0);
709 regs_.set_sp(0x10000);
710 regs_.FakeSetReturnAddress(0x1204);
711 regs_.FakeSetReturnAddressValid(true);
712
713 ElfInterfaceFake::FakePushStepData(StepData(0x23104, 0x10020, false));
714 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
715
716 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
717 unwinder.Unwind();
718 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
719 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
720
721 ASSERT_EQ(3U, unwinder.NumFrames());
722
723 auto* frame = &unwinder.frames()[0];
724 EXPECT_EQ(0U, frame->num);
725 EXPECT_EQ(0U, frame->rel_pc);
726 EXPECT_EQ(0U, frame->pc);
727 EXPECT_EQ(0x10000U, frame->sp);
728 EXPECT_EQ("", frame->function_name);
729 EXPECT_EQ(0U, frame->function_offset);
730 ASSERT_TRUE(frame->map_info == nullptr);
731
732 frame = &unwinder.frames()[1];
733 EXPECT_EQ(1U, frame->num);
734 EXPECT_EQ(0x200U, frame->rel_pc);
735 EXPECT_EQ(0x1200U, frame->pc);
736 EXPECT_EQ(0x10000U, frame->sp);
737 EXPECT_EQ("Frame0", frame->function_name);
738 EXPECT_EQ(0U, frame->function_offset);
739 ASSERT_TRUE(frame->map_info != nullptr);
740 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
741 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
742 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
743 EXPECT_EQ(0U, frame->map_info->offset());
744 EXPECT_EQ(0x1000U, frame->map_info->start());
745 EXPECT_EQ(0x8000U, frame->map_info->end());
746 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
747 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
748
749 frame = &unwinder.frames()[2];
750 EXPECT_EQ(2U, frame->num);
751 EXPECT_EQ(0x100U, frame->rel_pc);
752 EXPECT_EQ(0x23100U, frame->pc);
753 EXPECT_EQ(0x10020U, frame->sp);
754 EXPECT_EQ("Frame1", frame->function_name);
755 EXPECT_EQ(1U, frame->function_offset);
756 ASSERT_TRUE(frame->map_info != nullptr);
757 EXPECT_EQ("/fake/libanother.so", frame->map_info->name());
758 EXPECT_EQ("/fake/libanother.so", frame->map_info->GetFullName());
759 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
760 EXPECT_EQ(0U, frame->map_info->offset());
761 EXPECT_EQ(0x23000U, frame->map_info->start());
762 EXPECT_EQ(0x24000U, frame->map_info->end());
763 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
764 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
765 }
766
767 // Verify that a speculative frame is added then removed because no other
768 // frames are added.
TEST_F(UnwinderTest,speculative_frame_removed)769 TEST_F(UnwinderTest, speculative_frame_removed) {
770 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
771 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
772
773 // Fake as if code called a nullptr function.
774 regs_.set_pc(0x20000);
775 regs_.set_sp(0x10000);
776 ElfInterfaceFake::FakePushStepData(StepData(0, 0x10010, false));
777 regs_.FakeSetReturnAddress(0x12);
778 regs_.FakeSetReturnAddressValid(true);
779
780 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
781 unwinder.Unwind();
782 EXPECT_EQ(ERROR_INVALID_MAP, unwinder.LastErrorCode());
783 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
784
785 ASSERT_EQ(2U, unwinder.NumFrames());
786
787 auto* frame = &unwinder.frames()[0];
788 EXPECT_EQ(0U, frame->num);
789 EXPECT_EQ(0U, frame->rel_pc);
790 EXPECT_EQ(0x20000U, frame->pc);
791 EXPECT_EQ(0x10000U, frame->sp);
792 EXPECT_EQ("Frame0", frame->function_name);
793 EXPECT_EQ(0U, frame->function_offset);
794 ASSERT_TRUE(frame->map_info != nullptr);
795 EXPECT_EQ("/system/fake/libunwind.so", frame->map_info->name());
796 EXPECT_EQ("/system/fake/libunwind.so", frame->map_info->GetFullName());
797 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
798 EXPECT_EQ(0U, frame->map_info->offset());
799 EXPECT_EQ(0x20000U, frame->map_info->start());
800 EXPECT_EQ(0x22000U, frame->map_info->end());
801 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
802 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
803
804 frame = &unwinder.frames()[1];
805 EXPECT_EQ(1U, frame->num);
806 EXPECT_EQ(0U, frame->rel_pc);
807 EXPECT_EQ(0U, frame->pc);
808 EXPECT_EQ(0x10010U, frame->sp);
809 EXPECT_EQ("", frame->function_name);
810 EXPECT_EQ(0U, frame->function_offset);
811 ASSERT_TRUE(frame->map_info == nullptr);
812 }
813
814 // Verify that a speculative frame is added and left if there are only
815 // two frames and the pc is in the middle nowhere.
TEST_F(UnwinderTest,speculative_frame_not_removed_pc_bad)816 TEST_F(UnwinderTest, speculative_frame_not_removed_pc_bad) {
817 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
818 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
819
820 // Fake as if code called a nullptr function.
821 regs_.set_pc(0);
822 regs_.set_sp(0x10000);
823 regs_.FakeSetReturnAddress(0x1204);
824 regs_.FakeSetReturnAddressValid(true);
825
826 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
827 unwinder.Unwind();
828 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
829 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
830
831 ASSERT_EQ(2U, unwinder.NumFrames());
832
833 auto* frame = &unwinder.frames()[0];
834 EXPECT_EQ(0U, frame->num);
835 EXPECT_EQ(0U, frame->rel_pc);
836 EXPECT_EQ(0U, frame->pc);
837 EXPECT_EQ(0x10000U, frame->sp);
838 EXPECT_EQ("", frame->function_name);
839 EXPECT_EQ(0U, frame->function_offset);
840 ASSERT_TRUE(frame->map_info == nullptr);
841
842 frame = &unwinder.frames()[1];
843 EXPECT_EQ(1U, frame->num);
844 EXPECT_EQ(0x200U, frame->rel_pc);
845 EXPECT_EQ(0x1200U, frame->pc);
846 EXPECT_EQ(0x10000U, frame->sp);
847 EXPECT_EQ("Frame0", frame->function_name);
848 EXPECT_EQ(0U, frame->function_offset);
849 ASSERT_TRUE(frame->map_info != nullptr);
850 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
851 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
852 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
853 EXPECT_EQ(0U, frame->map_info->offset());
854 EXPECT_EQ(0x1000U, frame->map_info->start());
855 EXPECT_EQ(0x8000U, frame->map_info->end());
856 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
857 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
858 }
859
860 // Verify that a speculative frame does not cause a crash when it wasn't
861 // really added due to a filter.
TEST_F(UnwinderTest,speculative_frame_check_with_no_frames)862 TEST_F(UnwinderTest, speculative_frame_check_with_no_frames) {
863 regs_.set_pc(0x23000);
864 regs_.set_sp(0x10000);
865 regs_.FakeSetReturnAddress(0x23100);
866 regs_.FakeSetReturnAddressValid(true);
867
868 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
869
870 std::vector<std::string> skip_names{"libanother.so"};
871 unwinder.Unwind(&skip_names);
872 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
873 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
874
875 ASSERT_EQ(0U, unwinder.NumFrames());
876 }
877
878 // Verify that a speculative frame mapping to invalid map doesn't hide error
879 // for the previous frame.
TEST_F(UnwinderTest,speculative_frame_to_invalid_map_not_hide_prev_error)880 TEST_F(UnwinderTest, speculative_frame_to_invalid_map_not_hide_prev_error) {
881 regs_.set_pc(0x100000);
882 regs_.set_sp(0x10000);
883 regs_.FakeSetReturnAddress(0x4);
884 regs_.FakeSetReturnAddressValid(true);
885
886 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
887 unwinder.Unwind();
888 EXPECT_EQ(ERROR_INVALID_ELF, unwinder.LastErrorCode());
889 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
890
891 ASSERT_EQ(1U, unwinder.NumFrames());
892
893 auto* frame = &unwinder.frames()[0];
894 EXPECT_EQ(0U, frame->num);
895 EXPECT_EQ(0x300U, frame->rel_pc);
896 EXPECT_EQ(0x100000U, frame->pc);
897 EXPECT_EQ(0x10000U, frame->sp);
898 EXPECT_EQ("", frame->function_name);
899 EXPECT_EQ(0U, frame->function_offset);
900 ASSERT_TRUE(frame->map_info != nullptr);
901 }
902
903 // Verify that an unwind stops when a frame is in given suffix.
TEST_F(UnwinderTest,map_ignore_suffixes)904 TEST_F(UnwinderTest, map_ignore_suffixes) {
905 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
906 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
907 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
908 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame3", 3));
909
910 // Fake as if code called a nullptr function.
911 regs_.set_pc(0x1000);
912 regs_.set_sp(0x10000);
913 ElfInterfaceFake::FakePushStepData(StepData(0x43404, 0x10010, false));
914 ElfInterfaceFake::FakePushStepData(StepData(0x53504, 0x10020, false));
915 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
916
917 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
918 std::vector<std::string> suffixes{"oat"};
919 unwinder.Unwind(nullptr, &suffixes);
920 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
921 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
922
923 ASSERT_EQ(2U, unwinder.NumFrames());
924 // Make sure the elf was not initialized.
925 MapInfo* map_info = maps_->Find(0x53000).get();
926 ASSERT_TRUE(map_info != nullptr);
927 EXPECT_TRUE(map_info->elf() == nullptr);
928
929 auto* frame = &unwinder.frames()[0];
930 EXPECT_EQ(0U, frame->num);
931 EXPECT_EQ(0U, frame->rel_pc);
932 EXPECT_EQ(0x1000U, frame->pc);
933 EXPECT_EQ(0x10000U, frame->sp);
934 EXPECT_EQ("Frame0", frame->function_name);
935 EXPECT_EQ(0U, frame->function_offset);
936 ASSERT_TRUE(frame->map_info != nullptr);
937 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
938 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
939 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
940 EXPECT_EQ(0U, frame->map_info->offset());
941 EXPECT_EQ(0x1000U, frame->map_info->start());
942 EXPECT_EQ(0x8000U, frame->map_info->end());
943 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
944 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
945
946 frame = &unwinder.frames()[1];
947 EXPECT_EQ(1U, frame->num);
948 EXPECT_EQ(0x400U, frame->rel_pc);
949 EXPECT_EQ(0x43400U, frame->pc);
950 EXPECT_EQ(0x10010U, frame->sp);
951 EXPECT_EQ("Frame1", frame->function_name);
952 EXPECT_EQ(1U, frame->function_offset);
953 ASSERT_TRUE(frame->map_info != nullptr);
954 EXPECT_EQ("/fake/fake.apk", frame->map_info->name());
955 EXPECT_EQ("/fake/fake.apk!lib_fake.so", frame->map_info->GetFullName());
956 EXPECT_EQ(0x1d000U, frame->map_info->elf_start_offset());
957 EXPECT_EQ(0x1d000U, frame->map_info->offset());
958 EXPECT_EQ(0x43000U, frame->map_info->start());
959 EXPECT_EQ(0x44000U, frame->map_info->end());
960 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
961 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
962 }
963
964 // Verify that an unwind stops when the sp and pc don't change.
TEST_F(UnwinderTest,sp_pc_do_not_change)965 TEST_F(UnwinderTest, sp_pc_do_not_change) {
966 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
967 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
968 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2));
969 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame3", 3));
970 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame4", 4));
971
972 regs_.set_pc(0x1000);
973 regs_.set_sp(0x10000);
974 ElfInterfaceFake::FakePushStepData(StepData(0x33404, 0x10010, false));
975 ElfInterfaceFake::FakePushStepData(StepData(0x33504, 0x10020, false));
976 ElfInterfaceFake::FakePushStepData(StepData(0x33504, 0x10020, false));
977 ElfInterfaceFake::FakePushStepData(StepData(0x33504, 0x10020, false));
978 ElfInterfaceFake::FakePushStepData(StepData(0x33504, 0x10020, false));
979 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
980
981 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
982 unwinder.Unwind();
983 EXPECT_EQ(ERROR_REPEATED_FRAME, unwinder.LastErrorCode());
984 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
985
986 ASSERT_EQ(3U, unwinder.NumFrames());
987
988 auto* frame = &unwinder.frames()[0];
989 EXPECT_EQ(0U, frame->num);
990 EXPECT_EQ(0U, frame->rel_pc);
991 EXPECT_EQ(0x1000U, frame->pc);
992 EXPECT_EQ(0x10000U, frame->sp);
993 EXPECT_EQ("Frame0", frame->function_name);
994 EXPECT_EQ(0U, frame->function_offset);
995 ASSERT_TRUE(frame->map_info != nullptr);
996 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
997 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
998 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
999 EXPECT_EQ(0U, frame->map_info->offset());
1000 EXPECT_EQ(0x1000U, frame->map_info->start());
1001 EXPECT_EQ(0x8000U, frame->map_info->end());
1002 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1003 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
1004
1005 frame = &unwinder.frames()[1];
1006 EXPECT_EQ(1U, frame->num);
1007 EXPECT_EQ(0x400U, frame->rel_pc);
1008 EXPECT_EQ(0x33400U, frame->pc);
1009 EXPECT_EQ(0x10010U, frame->sp);
1010 EXPECT_EQ("Frame1", frame->function_name);
1011 EXPECT_EQ(1U, frame->function_offset);
1012 ASSERT_TRUE(frame->map_info != nullptr);
1013 EXPECT_EQ("/fake/compressed.so", frame->map_info->name());
1014 EXPECT_EQ("/fake/compressed.so", frame->map_info->GetFullName());
1015 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1016 EXPECT_EQ(0U, frame->map_info->offset());
1017 EXPECT_EQ(0x33000U, frame->map_info->start());
1018 EXPECT_EQ(0x34000U, frame->map_info->end());
1019 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1020 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
1021
1022 frame = &unwinder.frames()[2];
1023 EXPECT_EQ(2U, frame->num);
1024 EXPECT_EQ(0x500U, frame->rel_pc);
1025 EXPECT_EQ(0x33500U, frame->pc);
1026 EXPECT_EQ(0x10020U, frame->sp);
1027 EXPECT_EQ("Frame2", frame->function_name);
1028 EXPECT_EQ(2U, frame->function_offset);
1029 ASSERT_TRUE(frame->map_info != nullptr);
1030 EXPECT_EQ("/fake/compressed.so", frame->map_info->name());
1031 EXPECT_EQ("/fake/compressed.so", frame->map_info->GetFullName());
1032 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1033 EXPECT_EQ(0U, frame->map_info->offset());
1034 EXPECT_EQ(0x33000U, frame->map_info->start());
1035 EXPECT_EQ(0x34000U, frame->map_info->end());
1036 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1037 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
1038 }
1039
TEST_F(UnwinderTest,dex_pc_in_map)1040 TEST_F(UnwinderTest, dex_pc_in_map) {
1041 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1042 regs_.set_pc(0x1000);
1043 regs_.set_sp(0x10000);
1044 regs_.FakeSetDexPc(0xa3400);
1045
1046 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1047 unwinder.Unwind();
1048 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1049 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
1050
1051 ASSERT_EQ(2U, unwinder.NumFrames());
1052
1053 auto* frame = &unwinder.frames()[0];
1054 EXPECT_EQ(0U, frame->num);
1055 EXPECT_EQ(0x400U, frame->rel_pc);
1056 EXPECT_EQ(0xa3400U, frame->pc);
1057 EXPECT_EQ(0x10000U, frame->sp);
1058 EXPECT_EQ("", frame->function_name);
1059 EXPECT_EQ(0U, frame->function_offset);
1060 ASSERT_TRUE(frame->map_info != nullptr);
1061 EXPECT_EQ("/fake/fake.vdex", frame->map_info->name());
1062 EXPECT_EQ("/fake/fake.vdex", frame->map_info->GetFullName());
1063 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1064 EXPECT_EQ(0U, frame->map_info->offset());
1065 EXPECT_EQ(0xa3000U, frame->map_info->start());
1066 EXPECT_EQ(0xa4000U, frame->map_info->end());
1067 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1068 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_info->flags());
1069
1070 frame = &unwinder.frames()[1];
1071 EXPECT_EQ(1U, frame->num);
1072 EXPECT_EQ(0U, frame->rel_pc);
1073 EXPECT_EQ(0x1000U, frame->pc);
1074 EXPECT_EQ(0x10000U, frame->sp);
1075 EXPECT_EQ("Frame0", frame->function_name);
1076 EXPECT_EQ(0U, frame->function_offset);
1077 ASSERT_TRUE(frame->map_info != nullptr);
1078 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
1079 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
1080 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1081 EXPECT_EQ(0U, frame->map_info->offset());
1082 EXPECT_EQ(0x1000U, frame->map_info->start());
1083 EXPECT_EQ(0x8000U, frame->map_info->end());
1084 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1085 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
1086 }
1087
TEST_F(UnwinderTest,dex_pc_in_map_non_zero_offset)1088 TEST_F(UnwinderTest, dex_pc_in_map_non_zero_offset) {
1089 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1090 regs_.set_pc(0x1000);
1091 regs_.set_sp(0x10000);
1092 regs_.FakeSetDexPc(0xd0400);
1093
1094 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1095 unwinder.Unwind();
1096 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1097 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
1098
1099 ASSERT_EQ(2U, unwinder.NumFrames());
1100
1101 auto* frame = &unwinder.frames()[0];
1102 EXPECT_EQ(0U, frame->num);
1103 EXPECT_EQ(0x400U, frame->rel_pc);
1104 EXPECT_EQ(0xd0400U, frame->pc);
1105 EXPECT_EQ(0x10000U, frame->sp);
1106 EXPECT_EQ("", frame->function_name);
1107 EXPECT_EQ(0U, frame->function_offset);
1108 ASSERT_TRUE(frame->map_info != nullptr);
1109 EXPECT_EQ("/fake/fake.apk", frame->map_info->name());
1110 EXPECT_EQ("/fake/fake.apk", frame->map_info->GetFullName());
1111 EXPECT_EQ(0x1000U, frame->map_info->elf_start_offset());
1112 EXPECT_EQ(0x1000U, frame->map_info->offset());
1113 EXPECT_EQ(0xd0000U, frame->map_info->start());
1114 EXPECT_EQ(0xd1000U, frame->map_info->end());
1115 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1116 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_info->flags());
1117
1118 frame = &unwinder.frames()[1];
1119 EXPECT_EQ(1U, frame->num);
1120 EXPECT_EQ(0U, frame->rel_pc);
1121 EXPECT_EQ(0x1000U, frame->pc);
1122 EXPECT_EQ(0x10000U, frame->sp);
1123 EXPECT_EQ("Frame0", frame->function_name);
1124 EXPECT_EQ(0U, frame->function_offset);
1125 ASSERT_TRUE(frame->map_info != nullptr);
1126 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
1127 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
1128 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1129 EXPECT_EQ(0U, frame->map_info->offset());
1130 EXPECT_EQ(0x1000U, frame->map_info->start());
1131 EXPECT_EQ(0x8000U, frame->map_info->end());
1132 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1133 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
1134 }
1135
TEST_F(UnwinderTest,dex_pc_not_in_map)1136 TEST_F(UnwinderTest, dex_pc_not_in_map) {
1137 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1138 regs_.set_pc(0x1000);
1139 regs_.set_sp(0x10000);
1140 regs_.FakeSetDexPc(0x50000);
1141
1142 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1143 unwinder.Unwind();
1144 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1145 EXPECT_EQ(WARNING_DEX_PC_NOT_IN_MAP, unwinder.warnings());
1146
1147 ASSERT_EQ(2U, unwinder.NumFrames());
1148
1149 auto* frame = &unwinder.frames()[0];
1150 EXPECT_EQ(0U, frame->num);
1151 EXPECT_EQ(0x50000U, frame->rel_pc);
1152 EXPECT_EQ(0x50000U, frame->pc);
1153 EXPECT_EQ(0x10000U, frame->sp);
1154 EXPECT_EQ("", frame->function_name);
1155 EXPECT_EQ(0U, frame->function_offset);
1156 ASSERT_TRUE(frame->map_info == nullptr);
1157
1158 frame = &unwinder.frames()[1];
1159 EXPECT_EQ(1U, frame->num);
1160 EXPECT_EQ(0U, frame->rel_pc);
1161 EXPECT_EQ(0x1000U, frame->pc);
1162 EXPECT_EQ(0x10000U, frame->sp);
1163 EXPECT_EQ("Frame0", frame->function_name);
1164 EXPECT_EQ(0U, frame->function_offset);
1165 ASSERT_TRUE(frame->map_info != nullptr);
1166 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
1167 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
1168 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1169 EXPECT_EQ(0U, frame->map_info->offset());
1170 EXPECT_EQ(0x1000U, frame->map_info->start());
1171 EXPECT_EQ(0x8000U, frame->map_info->end());
1172 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1173 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
1174 }
1175
TEST_F(UnwinderTest,dex_pc_not_in_map_valid_dex_files)1176 TEST_F(UnwinderTest, dex_pc_not_in_map_valid_dex_files) {
1177 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1178 regs_.set_pc(0x1000);
1179 regs_.set_sp(0x10000);
1180 regs_.FakeSetDexPc(0x50000);
1181
1182 std::unique_ptr<DexFiles> dex_files = CreateDexFiles(regs_.Arch(), process_memory_);
1183 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1184 unwinder.SetDexFiles(dex_files.get());
1185 unwinder.Unwind();
1186 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1187 EXPECT_EQ(WARNING_DEX_PC_NOT_IN_MAP, unwinder.warnings());
1188
1189 ASSERT_EQ(2U, unwinder.NumFrames());
1190
1191 auto* frame = &unwinder.frames()[0];
1192 EXPECT_EQ(0U, frame->num);
1193 EXPECT_EQ(0x50000U, frame->rel_pc);
1194 EXPECT_EQ(0x50000U, frame->pc);
1195 EXPECT_EQ(0x10000U, frame->sp);
1196 EXPECT_EQ("", frame->function_name);
1197 EXPECT_EQ(0U, frame->function_offset);
1198 ASSERT_TRUE(frame->map_info == nullptr);
1199
1200 frame = &unwinder.frames()[1];
1201 EXPECT_EQ(1U, frame->num);
1202 EXPECT_EQ(0U, frame->rel_pc);
1203 EXPECT_EQ(0x1000U, frame->pc);
1204 EXPECT_EQ(0x10000U, frame->sp);
1205 EXPECT_EQ("Frame0", frame->function_name);
1206 EXPECT_EQ(0U, frame->function_offset);
1207 ASSERT_TRUE(frame->map_info != nullptr);
1208 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
1209 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
1210 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1211 EXPECT_EQ(0U, frame->map_info->offset());
1212 EXPECT_EQ(0x1000U, frame->map_info->start());
1213 EXPECT_EQ(0x8000U, frame->map_info->end());
1214 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1215 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
1216 }
1217
TEST_F(UnwinderTest,dex_pc_multiple_frames)1218 TEST_F(UnwinderTest, dex_pc_multiple_frames) {
1219 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1220 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1));
1221 regs_.set_pc(0x1000);
1222 regs_.set_sp(0x10000);
1223 regs_.FakeSetDexPc(0xa3400);
1224 ElfInterfaceFake::FakePushStepData(StepData(0x33404, 0x10010, false));
1225 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
1226
1227 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1228 unwinder.Unwind();
1229 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1230 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
1231
1232 ASSERT_EQ(3U, unwinder.NumFrames());
1233
1234 auto* frame = &unwinder.frames()[0];
1235 EXPECT_EQ(0U, frame->num);
1236 EXPECT_EQ(0x400U, frame->rel_pc);
1237 EXPECT_EQ(0xa3400U, frame->pc);
1238 EXPECT_EQ(0x10000U, frame->sp);
1239 EXPECT_EQ("", frame->function_name);
1240 EXPECT_EQ(0U, frame->function_offset);
1241 ASSERT_TRUE(frame->map_info != nullptr);
1242 EXPECT_EQ("/fake/fake.vdex", frame->map_info->GetFullName());
1243 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1244 EXPECT_EQ(0U, frame->map_info->offset());
1245 EXPECT_EQ(0xa3000U, frame->map_info->start());
1246 EXPECT_EQ(0xa4000U, frame->map_info->end());
1247 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1248 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_info->flags());
1249
1250 frame = &unwinder.frames()[1];
1251 EXPECT_EQ(1U, frame->num);
1252 EXPECT_EQ(0U, frame->rel_pc);
1253 EXPECT_EQ(0x1000U, frame->pc);
1254 EXPECT_EQ(0x10000U, frame->sp);
1255 EXPECT_EQ("Frame0", frame->function_name);
1256 EXPECT_EQ(0U, frame->function_offset);
1257 ASSERT_TRUE(frame->map_info != nullptr);
1258 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
1259 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
1260 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1261 EXPECT_EQ(0U, frame->map_info->offset());
1262 EXPECT_EQ(0x1000U, frame->map_info->start());
1263 EXPECT_EQ(0x8000U, frame->map_info->end());
1264 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1265 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
1266
1267 frame = &unwinder.frames()[2];
1268 EXPECT_EQ(2U, frame->num);
1269 EXPECT_EQ(0x400U, frame->rel_pc);
1270 EXPECT_EQ(0x33400U, frame->pc);
1271 EXPECT_EQ(0x10010U, frame->sp);
1272 EXPECT_EQ("Frame1", frame->function_name);
1273 EXPECT_EQ(1U, frame->function_offset);
1274 ASSERT_TRUE(frame->map_info != nullptr);
1275 EXPECT_EQ("/fake/compressed.so", frame->map_info->name());
1276 EXPECT_EQ("/fake/compressed.so", frame->map_info->GetFullName());
1277 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1278 EXPECT_EQ(0U, frame->map_info->offset());
1279 EXPECT_EQ(0x33000U, frame->map_info->start());
1280 EXPECT_EQ(0x34000U, frame->map_info->end());
1281 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1282 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
1283 }
1284
TEST_F(UnwinderTest,dex_pc_max_frames)1285 TEST_F(UnwinderTest, dex_pc_max_frames) {
1286 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1287 regs_.set_pc(0x1000);
1288 regs_.set_sp(0x10000);
1289 regs_.FakeSetDexPc(0xa3400);
1290
1291 Unwinder unwinder(1, maps_.get(), ®s_, process_memory_);
1292 unwinder.Unwind();
1293 EXPECT_EQ(ERROR_MAX_FRAMES_EXCEEDED, unwinder.LastErrorCode());
1294 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
1295
1296 ASSERT_EQ(1U, unwinder.NumFrames());
1297
1298 auto* frame = &unwinder.frames()[0];
1299 EXPECT_EQ(0U, frame->num);
1300 EXPECT_EQ(0x400U, frame->rel_pc);
1301 EXPECT_EQ(0xa3400U, frame->pc);
1302 EXPECT_EQ(0x10000U, frame->sp);
1303 EXPECT_EQ("", frame->function_name);
1304 EXPECT_EQ(0U, frame->function_offset);
1305 ASSERT_TRUE(frame->map_info != nullptr);
1306 EXPECT_EQ("/fake/fake.vdex", frame->map_info->name());
1307 EXPECT_EQ("/fake/fake.vdex", frame->map_info->GetFullName());
1308 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1309 EXPECT_EQ(0U, frame->map_info->offset());
1310 EXPECT_EQ(0xa3000U, frame->map_info->start());
1311 EXPECT_EQ(0xa4000U, frame->map_info->end());
1312 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1313 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_info->flags());
1314 }
1315
TEST_F(UnwinderTest,dex_pc_vdex_in_apk)1316 TEST_F(UnwinderTest, dex_pc_vdex_in_apk) {
1317 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1318 regs_.set_pc(0x1000);
1319 regs_.set_sp(0x10000);
1320 regs_.FakeSetDexPc(0xa8400);
1321
1322 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1323 unwinder.Unwind();
1324 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1325 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
1326
1327 ASSERT_EQ(2U, unwinder.NumFrames());
1328
1329 auto* frame = &unwinder.frames()[0];
1330 EXPECT_EQ(0U, frame->num);
1331 EXPECT_EQ(0x400U, frame->rel_pc);
1332 EXPECT_EQ(0xa8400U, frame->pc);
1333 EXPECT_EQ(0x10000U, frame->sp);
1334 EXPECT_EQ("", frame->function_name);
1335 EXPECT_EQ(0U, frame->function_offset);
1336 ASSERT_TRUE(frame->map_info != nullptr);
1337 EXPECT_EQ("/fake/fake_vdex.apk", frame->map_info->name());
1338 EXPECT_EQ("/fake/fake_vdex.apk", frame->map_info->GetFullName());
1339 EXPECT_EQ(0x1000U, frame->map_info->elf_start_offset());
1340 EXPECT_EQ(0x1000U, frame->map_info->offset());
1341 EXPECT_EQ(0xa8000U, frame->map_info->start());
1342 EXPECT_EQ(0xa9000U, frame->map_info->end());
1343 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1344 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_info->flags());
1345
1346 frame = &unwinder.frames()[1];
1347 EXPECT_EQ(1U, frame->num);
1348 EXPECT_EQ(0U, frame->rel_pc);
1349 EXPECT_EQ(0x1000U, frame->pc);
1350 EXPECT_EQ(0x10000U, frame->sp);
1351 EXPECT_EQ("Frame0", frame->function_name);
1352 EXPECT_EQ(0U, frame->function_offset);
1353 ASSERT_TRUE(frame->map_info != nullptr);
1354 EXPECT_EQ("/system/fake/libc.so", frame->map_info->name());
1355 EXPECT_EQ("/system/fake/libc.so", frame->map_info->GetFullName());
1356 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1357 EXPECT_EQ(0U, frame->map_info->offset());
1358 EXPECT_EQ(0x1000U, frame->map_info->start());
1359 EXPECT_EQ(0x8000U, frame->map_info->end());
1360 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1361 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_info->flags());
1362 }
1363
TEST_F(UnwinderTest,elf_file_not_readable)1364 TEST_F(UnwinderTest, elf_file_not_readable) {
1365 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1366
1367 regs_.set_pc(0xc0050);
1368 regs_.set_sp(0x10000);
1369 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
1370
1371 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1372 unwinder.Unwind();
1373 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1374 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
1375
1376 ASSERT_EQ(1U, unwinder.NumFrames());
1377
1378 auto* frame = &unwinder.frames()[0];
1379 EXPECT_EQ(0U, frame->num);
1380 EXPECT_EQ(0x50U, frame->rel_pc);
1381 EXPECT_EQ(0xc0050U, frame->pc);
1382 EXPECT_EQ(0x10000U, frame->sp);
1383 EXPECT_EQ("Frame0", frame->function_name);
1384 EXPECT_EQ(0U, frame->function_offset);
1385 ASSERT_TRUE(frame->map_info != nullptr);
1386 EXPECT_TRUE(frame->map_info->ElfFileNotReadable());
1387 EXPECT_EQ("/fake/unreadable.so", frame->map_info->name());
1388 EXPECT_EQ("/fake/unreadable.so", frame->map_info->GetFullName());
1389 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1390 EXPECT_EQ(0U, frame->map_info->offset());
1391 EXPECT_EQ(0xc0000U, frame->map_info->start());
1392 EXPECT_EQ(0xc1000U, frame->map_info->end());
1393 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1394 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_info->flags());
1395 }
1396
TEST_F(UnwinderTest,elf_from_memory_but_no_valid_file_with_bracket)1397 TEST_F(UnwinderTest, elf_from_memory_but_no_valid_file_with_bracket) {
1398 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1399
1400 regs_.set_pc(0xc1050);
1401 regs_.set_sp(0x10000);
1402 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
1403
1404 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1405 unwinder.Unwind();
1406 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1407 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
1408
1409 ASSERT_EQ(1U, unwinder.NumFrames());
1410
1411 auto* frame = &unwinder.frames()[0];
1412 EXPECT_EQ(0U, frame->num);
1413 EXPECT_EQ(0x50U, frame->rel_pc);
1414 EXPECT_EQ(0xc1050U, frame->pc);
1415 EXPECT_EQ(0x10000U, frame->sp);
1416 EXPECT_EQ("Frame0", frame->function_name);
1417 EXPECT_EQ(0U, frame->function_offset);
1418 ASSERT_TRUE(frame->map_info != nullptr);
1419 EXPECT_EQ("[vdso]", frame->map_info->name());
1420 EXPECT_EQ("[vdso]", frame->map_info->GetFullName());
1421 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1422 EXPECT_EQ(0U, frame->map_info->offset());
1423 EXPECT_EQ(0xc1000U, frame->map_info->start());
1424 EXPECT_EQ(0xc2000U, frame->map_info->end());
1425 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1426 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_info->flags());
1427 }
1428
TEST_F(UnwinderTest,elf_from_memory_but_empty_filename)1429 TEST_F(UnwinderTest, elf_from_memory_but_empty_filename) {
1430 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1431
1432 regs_.set_pc(0xc2050);
1433 regs_.set_sp(0x10000);
1434 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
1435
1436 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1437 unwinder.Unwind();
1438 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1439 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
1440
1441 ASSERT_EQ(1U, unwinder.NumFrames());
1442
1443 auto* frame = &unwinder.frames()[0];
1444 EXPECT_EQ(0U, frame->num);
1445 EXPECT_EQ(0x50U, frame->rel_pc);
1446 EXPECT_EQ(0xc2050U, frame->pc);
1447 EXPECT_EQ(0x10000U, frame->sp);
1448 EXPECT_EQ("Frame0", frame->function_name);
1449 EXPECT_EQ(0U, frame->function_offset);
1450 ASSERT_TRUE(frame->map_info != nullptr);
1451 EXPECT_EQ("", frame->map_info->name());
1452 EXPECT_EQ("", frame->map_info->GetFullName());
1453 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1454 EXPECT_EQ(0U, frame->map_info->offset());
1455 EXPECT_EQ(0xc2000U, frame->map_info->start());
1456 EXPECT_EQ(0xc3000U, frame->map_info->end());
1457 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1458 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_info->flags());
1459 }
1460
TEST_F(UnwinderTest,elf_from_memory_but_from_memfd)1461 TEST_F(UnwinderTest, elf_from_memory_but_from_memfd) {
1462 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0));
1463
1464 regs_.set_pc(0xc3050);
1465 regs_.set_sp(0x10000);
1466 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true));
1467
1468 Unwinder unwinder(64, maps_.get(), ®s_, process_memory_);
1469 unwinder.Unwind();
1470 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode());
1471 EXPECT_EQ(WARNING_NONE, unwinder.warnings());
1472
1473 ASSERT_EQ(1U, unwinder.NumFrames());
1474
1475 auto* frame = &unwinder.frames()[0];
1476 EXPECT_EQ(0U, frame->num);
1477 EXPECT_EQ(0x50U, frame->rel_pc);
1478 EXPECT_EQ(0xc3050U, frame->pc);
1479 EXPECT_EQ(0x10000U, frame->sp);
1480 EXPECT_EQ("Frame0", frame->function_name);
1481 EXPECT_EQ(0U, frame->function_offset);
1482 ASSERT_TRUE(frame->map_info != nullptr);
1483 EXPECT_EQ("/memfd:/jit-cache", frame->map_info->name());
1484 EXPECT_EQ("/memfd:/jit-cache", frame->map_info->GetFullName());
1485 EXPECT_EQ(0U, frame->map_info->elf_start_offset());
1486 EXPECT_EQ(0U, frame->map_info->offset());
1487 EXPECT_EQ(0xc3000U, frame->map_info->start());
1488 EXPECT_EQ(0xc4000U, frame->map_info->end());
1489 EXPECT_EQ(0U, frame->map_info->GetLoadBias());
1490 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_info->flags());
1491 }
1492
1493 // Verify format frame code.
TEST_F(UnwinderTest,format_frame)1494 TEST_F(UnwinderTest, format_frame) {
1495 RegsFake regs_arm(10);
1496 regs_arm.FakeSetArch(ARCH_ARM);
1497 Unwinder unwinder32(10, maps_.get(), ®s_arm, process_memory_);
1498
1499 RegsFake regs_arm64(10);
1500 regs_arm64.FakeSetArch(ARCH_ARM64);
1501 Unwinder unwinder64(10, maps_.get(), ®s_arm64, process_memory_);
1502
1503 FrameData frame;
1504 frame.num = 1;
1505 frame.rel_pc = 0x1000;
1506 frame.pc = 0x4000;
1507 frame.sp = 0x1000;
1508 frame.function_name = "function";
1509 frame.function_offset = 100;
1510 auto map_info = MapInfo::Create(0x3000, 0x6000, 0, PROT_READ, "/fake/libfake.so");
1511 map_info->set_elf_start_offset(0x2000);
1512 frame.map_info = map_info;
1513
1514 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so (offset 0x2000) (function+100)",
1515 unwinder64.FormatFrame(frame));
1516 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (offset 0x2000) (function+100)",
1517 unwinder32.FormatFrame(frame));
1518
1519 map_info->set_elf_start_offset(0);
1520 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so (function+100)",
1521 unwinder64.FormatFrame(frame));
1522 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (function+100)", unwinder32.FormatFrame(frame));
1523
1524 frame.function_offset = 0;
1525 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so (function)",
1526 unwinder64.FormatFrame(frame));
1527 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (function)", unwinder32.FormatFrame(frame));
1528
1529 // Verify the function name is demangled.
1530 frame.function_name = "_ZN4funcEv";
1531 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so (func())", unwinder64.FormatFrame(frame));
1532 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (func())", unwinder32.FormatFrame(frame));
1533
1534 frame.function_name = "";
1535 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so", unwinder64.FormatFrame(frame));
1536 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so", unwinder32.FormatFrame(frame));
1537
1538 map_info->name() = "";
1539 EXPECT_EQ(" #01 pc 0000000000001000 <anonymous:3000>", unwinder64.FormatFrame(frame));
1540 EXPECT_EQ(" #01 pc 00001000 <anonymous:3000>", unwinder32.FormatFrame(frame));
1541
1542 frame.map_info = nullptr;
1543 EXPECT_EQ(" #01 pc 0000000000001000 <unknown>", unwinder64.FormatFrame(frame));
1544 EXPECT_EQ(" #01 pc 00001000 <unknown>", unwinder32.FormatFrame(frame));
1545 }
1546
TEST_F(UnwinderTest,format_frame_build_id)1547 TEST_F(UnwinderTest, format_frame_build_id) {
1548 RegsFake regs(10);
1549 regs.FakeSetArch(ARCH_ARM);
1550 Unwinder unwinder(10, maps_.get(), ®s, process_memory_);
1551
1552 FrameData frame;
1553 frame.num = 1;
1554 frame.rel_pc = 0x1000;
1555 frame.pc = 0x4000;
1556 frame.sp = 0x1000;
1557 frame.function_name = "function";
1558 frame.function_offset = 100;
1559 frame.map_info = MapInfo::Create(0x3000, 0x6000, 0, PROT_READ, "/fake/libfake.so");
1560 SharedString* build_id = new SharedString(std::string{0x46, 0x41, 0x4b, 0x45});
1561 frame.map_info->set_build_id(build_id);
1562
1563 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (function+100)", unwinder.FormatFrame(frame));
1564 unwinder.SetDisplayBuildID(true);
1565 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (function+100) (BuildId: 46414b45)",
1566 unwinder.FormatFrame(frame));
1567 }
1568
ArchToString(ArchEnum arch)1569 static std::string ArchToString(ArchEnum arch) {
1570 if (arch == ARCH_ARM) {
1571 return "Arm";
1572 } else if (arch == ARCH_ARM64) {
1573 return "Arm64";
1574 } else if (arch == ARCH_RISCV64) {
1575 return "Riscv64";
1576 } else if (arch == ARCH_X86) {
1577 return "X86";
1578 } else if (arch == ARCH_X86_64) {
1579 return "X86_64";
1580 } else {
1581 return "Unknown";
1582 }
1583 }
1584
1585 // Verify format frame code.
TEST_F(UnwinderTest,format_frame_by_arch)1586 TEST_F(UnwinderTest, format_frame_by_arch) {
1587 std::vector<Regs*> reg_list;
1588 RegsArm* arm = new RegsArm;
1589 arm->set_pc(0x2300);
1590 arm->set_sp(0x10000);
1591 reg_list.push_back(arm);
1592
1593 RegsArm64* arm64 = new RegsArm64;
1594 arm64->set_pc(0x2300);
1595 arm64->set_sp(0x10000);
1596 reg_list.push_back(arm64);
1597
1598 RegsRiscv64* riscv64 = new RegsRiscv64;
1599 riscv64->set_pc(0x2300);
1600 riscv64->set_sp(0x10000);
1601 reg_list.push_back(riscv64);
1602
1603 RegsX86* x86 = new RegsX86;
1604 x86->set_pc(0x2300);
1605 x86->set_sp(0x10000);
1606 reg_list.push_back(x86);
1607
1608 RegsX86_64* x86_64 = new RegsX86_64;
1609 x86_64->set_pc(0x2300);
1610 x86_64->set_sp(0x10000);
1611 reg_list.push_back(x86_64);
1612
1613 for (auto regs : reg_list) {
1614 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 10));
1615
1616 Unwinder unwinder(64, maps_.get(), regs, process_memory_);
1617 unwinder.Unwind();
1618
1619 ASSERT_EQ(1U, unwinder.NumFrames());
1620 std::string expected;
1621 switch (regs->Arch()) {
1622 case ARCH_ARM:
1623 case ARCH_X86:
1624 expected = " #00 pc 00001300 /system/fake/libc.so (Frame0+10)";
1625 break;
1626 case ARCH_ARM64:
1627 case ARCH_X86_64:
1628 case ARCH_RISCV64:
1629 expected = " #00 pc 0000000000001300 /system/fake/libc.so (Frame0+10)";
1630 break;
1631 default:
1632 expected = "";
1633 }
1634 EXPECT_EQ(expected, unwinder.FormatFrame(0))
1635 << "Mismatch of frame format for regs arch " << ArchToString(regs->Arch());
1636 delete regs;
1637 }
1638 }
1639
TEST_F(UnwinderTest,build_frame_pc_only_errors)1640 TEST_F(UnwinderTest, build_frame_pc_only_errors) {
1641 RegsFake regs(10);
1642 regs.FakeSetArch(ARCH_ARM);
1643 Unwinder unwinder(10, maps_.get(), ®s, process_memory_);
1644
1645 FrameData frame;
1646
1647 // Pc not in map
1648 frame = unwinder.BuildFrameFromPcOnly(0x10);
1649 EXPECT_EQ(0x10U, frame.pc);
1650 EXPECT_EQ(0x10U, frame.rel_pc);
1651
1652 // No regs set
1653 unwinder.SetRegs(nullptr);
1654 frame = unwinder.BuildFrameFromPcOnly(0x100310);
1655 EXPECT_EQ(0x100310U, frame.pc);
1656 EXPECT_EQ(0x100310U, frame.rel_pc);
1657 unwinder.SetRegs(®s);
1658
1659 // Invalid elf
1660 frame = unwinder.BuildFrameFromPcOnly(0x100310);
1661 EXPECT_EQ(0x10030eU, frame.pc);
1662 EXPECT_EQ(0x60eU, frame.rel_pc);
1663 ASSERT_TRUE(frame.map_info != nullptr);
1664 EXPECT_EQ("/fake/jit.so", frame.map_info->name());
1665 EXPECT_EQ("/fake/jit.so", frame.map_info->GetFullName());
1666 EXPECT_EQ(0x100U, frame.map_info->elf_start_offset());
1667 EXPECT_EQ(0x200U, frame.map_info->offset());
1668 EXPECT_EQ(0x100000U, frame.map_info->start());
1669 EXPECT_EQ(0x101000U, frame.map_info->end());
1670 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame.map_info->flags());
1671 EXPECT_EQ(0U, frame.map_info->GetLoadBias());
1672 EXPECT_EQ("", frame.function_name);
1673 EXPECT_EQ(0U, frame.function_offset);
1674 }
1675
TEST_F(UnwinderTest,build_frame_pc_valid_elf)1676 TEST_F(UnwinderTest, build_frame_pc_valid_elf) {
1677 RegsFake regs(10);
1678 regs.FakeSetArch(ARCH_ARM);
1679 Unwinder unwinder(10, maps_.get(), ®s, process_memory_);
1680
1681 FrameData frame;
1682
1683 // Valid elf, no function data.
1684 frame = unwinder.BuildFrameFromPcOnly(0x1010);
1685 EXPECT_EQ(0x100cU, frame.pc);
1686 EXPECT_EQ(0xcU, frame.rel_pc);
1687 ASSERT_TRUE(frame.map_info != nullptr);
1688 EXPECT_EQ("/system/fake/libc.so", frame.map_info->name());
1689 EXPECT_EQ("/system/fake/libc.so", frame.map_info->GetFullName());
1690 EXPECT_EQ(0U, frame.map_info->elf_start_offset());
1691 EXPECT_EQ(0U, frame.map_info->offset());
1692 EXPECT_EQ(0x1000U, frame.map_info->start());
1693 EXPECT_EQ(0x8000U, frame.map_info->end());
1694 EXPECT_EQ(PROT_READ | PROT_WRITE, frame.map_info->flags());
1695 EXPECT_EQ(0U, frame.map_info->GetLoadBias());
1696 EXPECT_EQ("", frame.function_name);
1697 EXPECT_EQ(0U, frame.function_offset);
1698
1699 // Valid elf, function data present, but do not resolve.
1700 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 10));
1701 unwinder.SetResolveNames(false);
1702
1703 frame = unwinder.BuildFrameFromPcOnly(0x1010);
1704 EXPECT_EQ(0x100cU, frame.pc);
1705 EXPECT_EQ(0xcU, frame.rel_pc);
1706 ASSERT_TRUE(frame.map_info != nullptr);
1707 EXPECT_EQ("/system/fake/libc.so", frame.map_info->name());
1708 EXPECT_EQ("/system/fake/libc.so", frame.map_info->GetFullName());
1709 EXPECT_EQ(0U, frame.map_info->elf_start_offset());
1710 EXPECT_EQ(0U, frame.map_info->offset());
1711 EXPECT_EQ(0x1000U, frame.map_info->start());
1712 EXPECT_EQ(0x8000U, frame.map_info->end());
1713 EXPECT_EQ(PROT_READ | PROT_WRITE, frame.map_info->flags());
1714 EXPECT_EQ(0U, frame.map_info->GetLoadBias());
1715 EXPECT_EQ("", frame.function_name);
1716 EXPECT_EQ(0U, frame.function_offset);
1717
1718 // Valid elf, function data present.
1719 unwinder.SetResolveNames(true);
1720
1721 frame = unwinder.BuildFrameFromPcOnly(0x1010);
1722 EXPECT_EQ(0x100cU, frame.pc);
1723 EXPECT_EQ(0xcU, frame.rel_pc);
1724 ASSERT_TRUE(frame.map_info != nullptr);
1725 EXPECT_EQ("/system/fake/libc.so", frame.map_info->name());
1726 EXPECT_EQ("/system/fake/libc.so", frame.map_info->GetFullName());
1727 EXPECT_EQ(0U, frame.map_info->elf_start_offset());
1728 EXPECT_EQ(0U, frame.map_info->offset());
1729 EXPECT_EQ(0x1000U, frame.map_info->start());
1730 EXPECT_EQ(0x8000U, frame.map_info->end());
1731 EXPECT_EQ(PROT_READ | PROT_WRITE, frame.map_info->flags());
1732 EXPECT_EQ(0U, frame.map_info->GetLoadBias());
1733 EXPECT_EQ("Frame0", frame.function_name);
1734 EXPECT_EQ(10U, frame.function_offset);
1735 }
1736
TEST_F(UnwinderTest,build_frame_pc_in_jit)1737 TEST_F(UnwinderTest, build_frame_pc_in_jit) {
1738 // The whole ELF will be copied (read), so it must be valid (readable) memory.
1739 memory_->SetMemoryBlock(0xf7000, 0x1000, 0);
1740
1741 Elf32_Ehdr ehdr = {};
1742 TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, EM_ARM);
1743 ehdr.e_phoff = 0x50;
1744 ehdr.e_phnum = 1;
1745 ehdr.e_phentsize = sizeof(Elf32_Phdr);
1746 ehdr.e_shoff = 0x100;
1747 ehdr.e_shstrndx = 1;
1748 ehdr.e_shentsize = sizeof(Elf32_Shdr);
1749 ehdr.e_shnum = 3;
1750 memory_->SetMemory(0xf7000, &ehdr, sizeof(ehdr));
1751
1752 Elf32_Phdr phdr = {};
1753 phdr.p_flags = PF_X;
1754 phdr.p_type = PT_LOAD;
1755 phdr.p_offset = 0x100000;
1756 phdr.p_vaddr = 0x100000;
1757 phdr.p_memsz = 0x1000;
1758 memory_->SetMemory(0xf7050, &phdr, sizeof(phdr));
1759
1760 Elf32_Shdr shdr = {};
1761 shdr.sh_type = SHT_NULL;
1762 memory_->SetMemory(0xf7100, &shdr, sizeof(shdr));
1763
1764 shdr.sh_type = SHT_SYMTAB;
1765 shdr.sh_link = 2;
1766 shdr.sh_addr = 0x300;
1767 shdr.sh_offset = 0x300;
1768 shdr.sh_entsize = sizeof(Elf32_Sym);
1769 shdr.sh_size = shdr.sh_entsize;
1770 memory_->SetMemory(0xf7100 + sizeof(shdr), &shdr, sizeof(shdr));
1771
1772 memset(&shdr, 0, sizeof(shdr));
1773 shdr.sh_type = SHT_STRTAB;
1774 shdr.sh_name = 0x500;
1775 shdr.sh_offset = 0x400;
1776 shdr.sh_size = 0x100;
1777 memory_->SetMemory(0xf7100 + 2 * sizeof(shdr), &shdr, sizeof(shdr));
1778
1779 Elf32_Sym sym = {};
1780 sym.st_shndx = 2;
1781 sym.st_info = STT_FUNC;
1782 sym.st_value = 0x100300;
1783 sym.st_size = 0x100;
1784 sym.st_name = 1;
1785 memory_->SetMemory(0xf7300, &sym, sizeof(sym));
1786 memory_->SetMemory(0xf7401, "FakeJitFunction");
1787
1788 RegsFake regs(10);
1789 regs.FakeSetArch(ARCH_ARM);
1790 std::unique_ptr<JitDebug> jit_debug = CreateJitDebug(regs.Arch(), process_memory_);
1791 Unwinder unwinder(10, maps_.get(), ®s, process_memory_);
1792 unwinder.SetJitDebug(jit_debug.get());
1793
1794 FrameData frame = unwinder.BuildFrameFromPcOnly(0x100310);
1795 EXPECT_EQ(0x10030eU, frame.pc);
1796 EXPECT_EQ(0x60eU, frame.rel_pc);
1797 ASSERT_TRUE(frame.map_info != nullptr);
1798 EXPECT_EQ("/fake/jit.so", frame.map_info->name());
1799 EXPECT_EQ("/fake/jit.so", frame.map_info->GetFullName());
1800 EXPECT_EQ(0x100U, frame.map_info->elf_start_offset());
1801 EXPECT_EQ(0x200U, frame.map_info->offset());
1802 EXPECT_EQ(0x100000U, frame.map_info->start());
1803 EXPECT_EQ(0x101000U, frame.map_info->end());
1804 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame.map_info->flags());
1805 EXPECT_EQ(0U, frame.map_info->GetLoadBias());
1806 EXPECT_EQ("FakeJitFunction", frame.function_name);
1807 EXPECT_EQ(0xeU, frame.function_offset);
1808 }
1809
TEST_F(UnwinderTest,unwinder_from_pid_set_process_memory)1810 TEST_F(UnwinderTest, unwinder_from_pid_set_process_memory) {
1811 auto process_memory = Memory::CreateProcessMemoryCached(getpid());
1812 UnwinderFromPid unwinder(10, getpid(), process_memory);
1813 unwinder.SetArch(unwindstack::Regs::CurrentArch());
1814 ASSERT_TRUE(unwinder.Init());
1815 ASSERT_EQ(process_memory.get(), unwinder.GetProcessMemory().get());
1816 }
1817
1818 using UnwinderDeathTest = SilentDeathTest;
1819
TEST_F(UnwinderDeathTest,unwinder_from_pid_init_error)1820 TEST_F(UnwinderDeathTest, unwinder_from_pid_init_error) {
1821 UnwinderFromPid unwinder(10, getpid());
1822 ASSERT_DEATH(unwinder.Init(), "");
1823 }
1824
TEST_F(UnwinderDeathTest,set_jit_debug_error)1825 TEST_F(UnwinderDeathTest, set_jit_debug_error) {
1826 Maps maps;
1827 std::shared_ptr<Memory> process_memory(new MemoryFake);
1828 Unwinder unwinder(10, &maps, process_memory);
1829 ASSERT_DEATH(CreateJitDebug(ARCH_UNKNOWN, process_memory), "");
1830 }
1831
TEST_F(UnwinderTest,unwinder_from_pid_with_external_maps)1832 TEST_F(UnwinderTest, unwinder_from_pid_with_external_maps) {
1833 LocalMaps map;
1834 ASSERT_TRUE(map.Parse());
1835
1836 UnwinderFromPid unwinder1(10, getpid(), &map);
1837 unwinder1.SetArch(Regs::CurrentArch());
1838 ASSERT_EQ(&map, unwinder1.GetMaps());
1839 ASSERT_TRUE(unwinder1.Init());
1840 ASSERT_EQ(&map, unwinder1.GetMaps());
1841
1842 UnwinderFromPid unwinder2(10, getpid(), Regs::CurrentArch(), &map);
1843 ASSERT_EQ(&map, unwinder2.GetMaps());
1844 ASSERT_TRUE(unwinder2.Init());
1845 ASSERT_EQ(&map, unwinder2.GetMaps());
1846 }
1847
TEST_F(UnwinderDeathTest,set_dex_files_error)1848 TEST_F(UnwinderDeathTest, set_dex_files_error) {
1849 Maps maps;
1850 std::shared_ptr<Memory> process_memory(new MemoryFake);
1851 Unwinder unwinder(10, &maps, process_memory);
1852 ASSERT_DEATH(CreateDexFiles(ARCH_UNKNOWN, process_memory), "");
1853 }
1854
1855 } // namespace unwindstack
1856