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