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