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