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