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 43namespace unwindstack { 44 45class MapsFake : public Maps { 46 public: 47 MapsFake() = default; 48 virtual ~MapsFake() = default; 49 50 bool Parse() { return true; } 51 52 void FakeClear() { maps_.clear(); } 53 54 void FakeAddMapInfo(MapInfo* map_info) { maps_.push_back(map_info); } 55}; 56 57class UnwinderTest : public ::testing::Test { 58 protected: 59 static void SetUpTestCase() { 60 maps_.FakeClear(); 61 MapInfo* info = new MapInfo(0x1000, 0x8000, 0, PROT_READ | PROT_WRITE, "/system/fake/libc.so"); 62 ElfFake* elf = new ElfFake(new MemoryFake); 63 info->elf.reset(elf); 64 elf->FakeSetInterface(new ElfInterfaceFake(nullptr)); 65 maps_.FakeAddMapInfo(info); 66 67 info = new MapInfo(0x10000, 0x12000, 0, PROT_READ | PROT_WRITE, "[stack]"); 68 maps_.FakeAddMapInfo(info); 69 70 info = new MapInfo(0x13000, 0x15000, 0, PROT_READ | PROT_WRITE | MAPS_FLAGS_DEVICE_MAP, 71 "/dev/fake_device"); 72 maps_.FakeAddMapInfo(info); 73 74 info = new MapInfo(0x20000, 0x22000, 0, PROT_READ | PROT_WRITE, "/system/fake/libunwind.so"); 75 elf = new ElfFake(new MemoryFake); 76 info->elf.reset(elf); 77 elf->FakeSetInterface(new ElfInterfaceFake(nullptr)); 78 maps_.FakeAddMapInfo(info); 79 80 info = new MapInfo(0x23000, 0x24000, 0, PROT_READ | PROT_WRITE, "/fake/libanother.so"); 81 elf = new ElfFake(new MemoryFake); 82 info->elf.reset(elf); 83 elf->FakeSetInterface(new ElfInterfaceFake(nullptr)); 84 maps_.FakeAddMapInfo(info); 85 86 info = new MapInfo(0x33000, 0x34000, 0, PROT_READ | PROT_WRITE, "/fake/compressed.so"); 87 elf = new ElfFake(new MemoryFake); 88 info->elf.reset(elf); 89 elf->FakeSetInterface(new ElfInterfaceFake(nullptr)); 90 maps_.FakeAddMapInfo(info); 91 92 info = new MapInfo(0x43000, 0x44000, 0x1d000, PROT_READ | PROT_WRITE, "/fake/fake.apk"); 93 elf = new ElfFake(new MemoryFake); 94 info->elf.reset(elf); 95 elf->FakeSetInterface(new ElfInterfaceFake(nullptr)); 96 maps_.FakeAddMapInfo(info); 97 98 info = new MapInfo(0x53000, 0x54000, 0, PROT_READ | PROT_WRITE, "/fake/fake.oat"); 99 maps_.FakeAddMapInfo(info); 100 101 info = new MapInfo(0xa3000, 0xa4000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, "/fake/fake.vdex"); 102 info->load_bias = 0; 103 maps_.FakeAddMapInfo(info); 104 105 info = new MapInfo(0xa5000, 0xa6000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, 106 "/fake/fake_load_bias.so"); 107 elf = new ElfFake(new MemoryFake); 108 info->elf.reset(elf); 109 elf->FakeSetInterface(new ElfInterfaceFake(nullptr)); 110 elf->FakeSetLoadBias(0x5000); 111 maps_.FakeAddMapInfo(info); 112 113 info = new MapInfo(0xa7000, 0xa8000, 0, PROT_READ | PROT_WRITE | PROT_EXEC, 114 "/fake/fake_offset.oat"); 115 elf = new ElfFake(new MemoryFake); 116 info->elf.reset(elf); 117 elf->FakeSetInterface(new ElfInterfaceFake(nullptr)); 118 info->elf_offset = 0x8000; 119 maps_.FakeAddMapInfo(info); 120 121 process_memory_.reset(new MemoryFake); 122 } 123 124 void SetUp() override { 125 ElfInterfaceFake::FakeClear(); 126 regs_.FakeSetArch(ARCH_ARM); 127 regs_.FakeSetReturnAddressValid(false); 128 } 129 130 static MapsFake maps_; 131 static RegsFake regs_; 132 static std::shared_ptr<Memory> process_memory_; 133}; 134 135MapsFake UnwinderTest::maps_; 136RegsFake UnwinderTest::regs_(5); 137std::shared_ptr<Memory> UnwinderTest::process_memory_(nullptr); 138 139TEST_F(UnwinderTest, multiple_frames) { 140 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 141 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1)); 142 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2)); 143 144 regs_.set_pc(0x1000); 145 regs_.set_sp(0x10000); 146 ElfInterfaceFake::FakePushStepData(StepData(0x1102, 0x10010, false)); 147 ElfInterfaceFake::FakePushStepData(StepData(0x1202, 0x10020, false)); 148 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 149 150 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 151 unwinder.Unwind(); 152 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 153 154 ASSERT_EQ(3U, unwinder.NumFrames()); 155 156 auto* frame = &unwinder.frames()[0]; 157 EXPECT_EQ(0U, frame->num); 158 EXPECT_EQ(0U, frame->rel_pc); 159 EXPECT_EQ(0x1000U, frame->pc); 160 EXPECT_EQ(0x10000U, frame->sp); 161 EXPECT_EQ("Frame0", frame->function_name); 162 EXPECT_EQ(0U, frame->function_offset); 163 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 164 EXPECT_EQ(0U, frame->map_offset); 165 EXPECT_EQ(0x1000U, frame->map_start); 166 EXPECT_EQ(0x8000U, frame->map_end); 167 EXPECT_EQ(0U, frame->map_load_bias); 168 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 169 170 frame = &unwinder.frames()[1]; 171 EXPECT_EQ(1U, frame->num); 172 EXPECT_EQ(0x100U, frame->rel_pc); 173 EXPECT_EQ(0x1100U, frame->pc); 174 EXPECT_EQ(0x10010U, frame->sp); 175 EXPECT_EQ("Frame1", frame->function_name); 176 EXPECT_EQ(1U, frame->function_offset); 177 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 178 EXPECT_EQ(0U, frame->map_offset); 179 EXPECT_EQ(0x1000U, frame->map_start); 180 EXPECT_EQ(0x8000U, frame->map_end); 181 EXPECT_EQ(0U, frame->map_load_bias); 182 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 183 184 frame = &unwinder.frames()[2]; 185 EXPECT_EQ(2U, frame->num); 186 EXPECT_EQ(0x200U, frame->rel_pc); 187 EXPECT_EQ(0x1200U, frame->pc); 188 EXPECT_EQ(0x10020U, frame->sp); 189 EXPECT_EQ("Frame2", frame->function_name); 190 EXPECT_EQ(2U, frame->function_offset); 191 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 192 EXPECT_EQ(0U, frame->map_offset); 193 EXPECT_EQ(0x1000U, frame->map_start); 194 EXPECT_EQ(0x8000U, frame->map_end); 195 EXPECT_EQ(0U, frame->map_load_bias); 196 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 197} 198 199TEST_F(UnwinderTest, multiple_frames_dont_resolve_names) { 200 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 201 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1)); 202 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2)); 203 204 regs_.set_pc(0x1000); 205 regs_.set_sp(0x10000); 206 ElfInterfaceFake::FakePushStepData(StepData(0x1102, 0x10010, false)); 207 ElfInterfaceFake::FakePushStepData(StepData(0x1202, 0x10020, false)); 208 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 209 210 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 211 unwinder.SetResolveNames(false); 212 unwinder.Unwind(); 213 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 214 215 ASSERT_EQ(3U, unwinder.NumFrames()); 216 217 auto* frame = &unwinder.frames()[0]; 218 EXPECT_EQ(0U, frame->num); 219 EXPECT_EQ(0U, frame->rel_pc); 220 EXPECT_EQ(0x1000U, frame->pc); 221 EXPECT_EQ(0x10000U, frame->sp); 222 EXPECT_EQ("", frame->function_name); 223 EXPECT_EQ(0U, frame->function_offset); 224 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 225 EXPECT_EQ(0U, frame->map_offset); 226 EXPECT_EQ(0x1000U, frame->map_start); 227 EXPECT_EQ(0x8000U, frame->map_end); 228 EXPECT_EQ(0U, frame->map_load_bias); 229 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_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("", frame->function_name); 237 EXPECT_EQ(0U, frame->function_offset); 238 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 239 EXPECT_EQ(0U, frame->map_offset); 240 EXPECT_EQ(0x1000U, frame->map_start); 241 EXPECT_EQ(0x8000U, frame->map_end); 242 EXPECT_EQ(0U, frame->map_load_bias); 243 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 244 245 frame = &unwinder.frames()[2]; 246 EXPECT_EQ(2U, frame->num); 247 EXPECT_EQ(0x200U, frame->rel_pc); 248 EXPECT_EQ(0x1200U, frame->pc); 249 EXPECT_EQ(0x10020U, frame->sp); 250 EXPECT_EQ("", frame->function_name); 251 EXPECT_EQ(0U, frame->function_offset); 252 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 253 EXPECT_EQ(0U, frame->map_offset); 254 EXPECT_EQ(0x1000U, frame->map_start); 255 EXPECT_EQ(0x8000U, frame->map_end); 256 EXPECT_EQ(0U, frame->map_load_bias); 257 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 258} 259 260TEST_F(UnwinderTest, non_zero_load_bias) { 261 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 262 263 regs_.set_pc(0xa5500); 264 regs_.set_sp(0x10000); 265 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 266 267 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 268 unwinder.Unwind(); 269 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 270 271 ASSERT_EQ(1U, unwinder.NumFrames()); 272 273 auto* frame = &unwinder.frames()[0]; 274 EXPECT_EQ(0U, frame->num); 275 EXPECT_EQ(0x5500U, frame->rel_pc); 276 EXPECT_EQ(0xa5500U, frame->pc); 277 EXPECT_EQ(0x10000U, frame->sp); 278 EXPECT_EQ("Frame0", frame->function_name); 279 EXPECT_EQ(0U, frame->function_offset); 280 EXPECT_EQ("/fake/fake_load_bias.so", frame->map_name); 281 EXPECT_EQ(0U, frame->map_offset); 282 EXPECT_EQ(0xa5000U, frame->map_start); 283 EXPECT_EQ(0xa6000U, frame->map_end); 284 EXPECT_EQ(0x5000U, frame->map_load_bias); 285 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags); 286} 287 288TEST_F(UnwinderTest, non_zero_elf_offset) { 289 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 290 291 regs_.set_pc(0xa7500); 292 regs_.set_sp(0x10000); 293 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 294 295 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 296 unwinder.Unwind(); 297 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 298 299 ASSERT_EQ(1U, unwinder.NumFrames()); 300 301 auto* frame = &unwinder.frames()[0]; 302 EXPECT_EQ(0U, frame->num); 303 EXPECT_EQ(0x8500U, frame->rel_pc); 304 EXPECT_EQ(0xa7500U, frame->pc); 305 EXPECT_EQ(0x10000U, frame->sp); 306 EXPECT_EQ("Frame0", frame->function_name); 307 EXPECT_EQ(0U, frame->function_offset); 308 EXPECT_EQ("/fake/fake_offset.oat", frame->map_name); 309 EXPECT_EQ(0U, frame->map_offset); 310 EXPECT_EQ(0xa7000U, frame->map_start); 311 EXPECT_EQ(0xa8000U, frame->map_end); 312 EXPECT_EQ(0U, frame->map_load_bias); 313 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags); 314} 315 316TEST_F(UnwinderTest, non_zero_map_offset) { 317 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 318 319 regs_.set_pc(0x43000); 320 regs_.set_sp(0x10000); 321 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 322 323 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 324 unwinder.Unwind(); 325 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 326 327 ASSERT_EQ(1U, unwinder.NumFrames()); 328 329 auto* frame = &unwinder.frames()[0]; 330 EXPECT_EQ(0U, frame->num); 331 EXPECT_EQ(0U, frame->rel_pc); 332 EXPECT_EQ(0x43000U, frame->pc); 333 EXPECT_EQ(0x10000U, frame->sp); 334 EXPECT_EQ("Frame0", frame->function_name); 335 EXPECT_EQ(0U, frame->function_offset); 336 EXPECT_EQ("/fake/fake.apk", frame->map_name); 337 EXPECT_EQ(0x1d000U, frame->map_offset); 338 EXPECT_EQ(0x43000U, frame->map_start); 339 EXPECT_EQ(0x44000U, frame->map_end); 340 EXPECT_EQ(0U, frame->map_load_bias); 341 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 342} 343 344// Verify that no attempt to continue after the step indicates it is done. 345TEST_F(UnwinderTest, no_frames_after_finished) { 346 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 347 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1)); 348 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2)); 349 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame3", 3)); 350 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame4", 4)); 351 352 regs_.set_pc(0x1000); 353 regs_.set_sp(0x10000); 354 ElfInterfaceFake::FakePushStepData(StepData(0x1000, 0x10000, true)); 355 ElfInterfaceFake::FakePushStepData(StepData(0x1102, 0x10010, false)); 356 ElfInterfaceFake::FakePushStepData(StepData(0x1202, 0x10020, false)); 357 358 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 359 unwinder.Unwind(); 360 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 361 362 ASSERT_EQ(1U, unwinder.NumFrames()); 363 364 auto* frame = &unwinder.frames()[0]; 365 EXPECT_EQ(0U, frame->num); 366 EXPECT_EQ(0U, frame->rel_pc); 367 EXPECT_EQ(0x1000U, frame->pc); 368 EXPECT_EQ(0x10000U, frame->sp); 369 EXPECT_EQ("Frame0", frame->function_name); 370 EXPECT_EQ(0U, frame->function_offset); 371 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 372 EXPECT_EQ(0U, frame->map_offset); 373 EXPECT_EQ(0x1000U, frame->map_start); 374 EXPECT_EQ(0x8000U, frame->map_end); 375 EXPECT_EQ(0U, frame->map_load_bias); 376 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 377} 378 379// Verify the maximum frames to save. 380TEST_F(UnwinderTest, max_frames) { 381 for (size_t i = 0; i < 30; i++) { 382 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame" + std::to_string(i), i)); 383 ElfInterfaceFake::FakePushStepData(StepData(0x1102 + i * 0x100, 0x10010 + i * 0x10, false)); 384 } 385 386 regs_.set_pc(0x1000); 387 regs_.set_sp(0x10000); 388 389 Unwinder unwinder(20, &maps_, ®s_, process_memory_); 390 unwinder.Unwind(); 391 EXPECT_EQ(ERROR_MAX_FRAMES_EXCEEDED, unwinder.LastErrorCode()); 392 393 ASSERT_EQ(20U, unwinder.NumFrames()); 394 395 for (size_t i = 0; i < 20; i++) { 396 auto* frame = &unwinder.frames()[i]; 397 EXPECT_EQ(i, frame->num); 398 EXPECT_EQ(i * 0x100, frame->rel_pc) << "Failed at frame " << i; 399 EXPECT_EQ(0x1000 + i * 0x100, frame->pc) << "Failed at frame " << i; 400 EXPECT_EQ(0x10000 + 0x10 * i, frame->sp) << "Failed at frame " << i; 401 EXPECT_EQ("Frame" + std::to_string(i), frame->function_name) << "Failed at frame " << i; 402 EXPECT_EQ(i, frame->function_offset) << "Failed at frame " << i; 403 EXPECT_EQ("/system/fake/libc.so", frame->map_name) << "Failed at frame " << i; 404 EXPECT_EQ(0U, frame->map_offset) << "Failed at frame " << i; 405 EXPECT_EQ(0x1000U, frame->map_start) << "Failed at frame " << i; 406 EXPECT_EQ(0x8000U, frame->map_end) << "Failed at frame " << i; 407 EXPECT_EQ(0U, frame->map_load_bias) << "Failed at frame " << i; 408 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags) << "Failed at frame " << i; 409 } 410} 411 412// Verify that initial map names frames are removed. 413TEST_F(UnwinderTest, verify_frames_skipped) { 414 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 415 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1)); 416 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2)); 417 418 regs_.set_pc(0x20000); 419 regs_.set_sp(0x10000); 420 ElfInterfaceFake::FakePushStepData(StepData(0x23002, 0x10010, false)); 421 ElfInterfaceFake::FakePushStepData(StepData(0x23102, 0x10020, false)); 422 ElfInterfaceFake::FakePushStepData(StepData(0x20002, 0x10030, false)); 423 ElfInterfaceFake::FakePushStepData(StepData(0x21002, 0x10040, false)); 424 ElfInterfaceFake::FakePushStepData(StepData(0x1002, 0x10050, false)); 425 ElfInterfaceFake::FakePushStepData(StepData(0x21002, 0x10060, false)); 426 ElfInterfaceFake::FakePushStepData(StepData(0x23002, 0x10070, false)); 427 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 428 429 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 430 std::vector<std::string> skip_libs{"libunwind.so", "libanother.so"}; 431 unwinder.Unwind(&skip_libs); 432 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 433 434 ASSERT_EQ(3U, unwinder.NumFrames()); 435 436 auto* frame = &unwinder.frames()[0]; 437 EXPECT_EQ(0U, frame->num); 438 EXPECT_EQ(0U, frame->rel_pc); 439 EXPECT_EQ(0x1000U, frame->pc); 440 EXPECT_EQ(0x10050U, frame->sp); 441 EXPECT_EQ("Frame0", frame->function_name); 442 EXPECT_EQ(0U, frame->function_offset); 443 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 444 EXPECT_EQ(0U, frame->map_offset); 445 EXPECT_EQ(0x1000U, frame->map_start); 446 EXPECT_EQ(0x8000U, frame->map_end); 447 EXPECT_EQ(0U, frame->map_load_bias); 448 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 449 450 frame = &unwinder.frames()[1]; 451 EXPECT_EQ(1U, frame->num); 452 EXPECT_EQ(0x1000U, frame->rel_pc); 453 EXPECT_EQ(0x21000U, frame->pc); 454 EXPECT_EQ(0x10060U, frame->sp); 455 EXPECT_EQ("Frame1", frame->function_name); 456 EXPECT_EQ(1U, frame->function_offset); 457 EXPECT_EQ("/system/fake/libunwind.so", frame->map_name); 458 EXPECT_EQ(0U, frame->map_offset); 459 EXPECT_EQ(0x20000U, frame->map_start); 460 EXPECT_EQ(0x22000U, frame->map_end); 461 EXPECT_EQ(0U, frame->map_load_bias); 462 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 463 464 frame = &unwinder.frames()[2]; 465 EXPECT_EQ(2U, frame->num); 466 EXPECT_EQ(0U, frame->rel_pc); 467 EXPECT_EQ(0x23000U, frame->pc); 468 EXPECT_EQ(0x10070U, frame->sp); 469 EXPECT_EQ("Frame2", frame->function_name); 470 EXPECT_EQ(2U, frame->function_offset); 471 EXPECT_EQ("/fake/libanother.so", frame->map_name); 472 EXPECT_EQ(0U, frame->map_offset); 473 EXPECT_EQ(0x23000U, frame->map_start); 474 EXPECT_EQ(0x24000U, frame->map_end); 475 EXPECT_EQ(0U, frame->map_load_bias); 476 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 477} 478 479// Verify SP in a non-existant map is okay. 480TEST_F(UnwinderTest, sp_not_in_map) { 481 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 482 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1)); 483 484 regs_.set_pc(0x1000); 485 regs_.set_sp(0x63000); 486 ElfInterfaceFake::FakePushStepData(StepData(0x21002, 0x50020, false)); 487 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 488 489 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 490 unwinder.Unwind(); 491 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 492 493 ASSERT_EQ(2U, unwinder.NumFrames()); 494 495 auto* frame = &unwinder.frames()[0]; 496 EXPECT_EQ(0U, frame->num); 497 EXPECT_EQ(0U, frame->rel_pc); 498 EXPECT_EQ(0x1000U, frame->pc); 499 EXPECT_EQ(0x63000U, frame->sp); 500 EXPECT_EQ("Frame0", frame->function_name); 501 EXPECT_EQ(0U, frame->function_offset); 502 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 503 EXPECT_EQ(0U, frame->map_offset); 504 EXPECT_EQ(0x1000U, frame->map_start); 505 EXPECT_EQ(0x8000U, frame->map_end); 506 EXPECT_EQ(0U, frame->map_load_bias); 507 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 508 509 frame = &unwinder.frames()[1]; 510 EXPECT_EQ(1U, frame->num); 511 EXPECT_EQ(0x1000U, frame->rel_pc); 512 EXPECT_EQ(0x21000U, frame->pc); 513 EXPECT_EQ(0x50020U, frame->sp); 514 EXPECT_EQ("Frame1", frame->function_name); 515 EXPECT_EQ(1U, frame->function_offset); 516 EXPECT_EQ("/system/fake/libunwind.so", frame->map_name); 517 EXPECT_EQ(0U, frame->map_offset); 518 EXPECT_EQ(0x20000U, frame->map_start); 519 EXPECT_EQ(0x22000U, frame->map_end); 520 EXPECT_EQ(0U, frame->map_load_bias); 521 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 522} 523 524// Verify PC in a device stops the unwind. 525TEST_F(UnwinderTest, pc_in_device_stops_unwind) { 526 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 527 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1)); 528 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2)); 529 530 regs_.set_pc(0x13000); 531 regs_.set_sp(0x10000); 532 ElfInterfaceFake::FakePushStepData(StepData(0x23002, 0x10010, false)); 533 ElfInterfaceFake::FakePushStepData(StepData(0x23102, 0x10020, false)); 534 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 535 536 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 537 unwinder.Unwind(); 538 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 539 540 ASSERT_EQ(1U, unwinder.NumFrames()); 541} 542 543// Verify SP in a device stops the unwind. 544TEST_F(UnwinderTest, sp_in_device_stops_unwind) { 545 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 546 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1)); 547 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2)); 548 549 regs_.set_pc(0x1000); 550 regs_.set_sp(0x13000); 551 ElfInterfaceFake::FakePushStepData(StepData(0x23002, 0x10010, false)); 552 ElfInterfaceFake::FakePushStepData(StepData(0x23102, 0x10020, false)); 553 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 554 555 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 556 unwinder.Unwind(); 557 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 558 559 ASSERT_EQ(1U, unwinder.NumFrames()); 560} 561 562// Verify a no map info frame gets a frame. 563TEST_F(UnwinderTest, pc_without_map) { 564 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 565 566 regs_.set_pc(0x41000); 567 regs_.set_sp(0x13000); 568 569 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 570 unwinder.Unwind(); 571 EXPECT_EQ(ERROR_INVALID_MAP, unwinder.LastErrorCode()); 572 573 ASSERT_EQ(1U, unwinder.NumFrames()); 574 575 auto* frame = &unwinder.frames()[0]; 576 EXPECT_EQ(0U, frame->num); 577 EXPECT_EQ(0x41000U, frame->rel_pc); 578 EXPECT_EQ(0x41000U, frame->pc); 579 EXPECT_EQ(0x13000U, frame->sp); 580 EXPECT_EQ("", frame->function_name); 581 EXPECT_EQ(0U, frame->function_offset); 582 EXPECT_EQ("", frame->map_name); 583 EXPECT_EQ(0U, frame->map_offset); 584 EXPECT_EQ(0U, frame->map_start); 585 EXPECT_EQ(0U, frame->map_end); 586 EXPECT_EQ(0U, frame->map_load_bias); 587 EXPECT_EQ(0, frame->map_flags); 588} 589 590// Verify that a speculative frame is added. 591TEST_F(UnwinderTest, speculative_frame) { 592 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 593 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1)); 594 595 // Fake as if code called a nullptr function. 596 regs_.set_pc(0); 597 regs_.set_sp(0x10000); 598 regs_.FakeSetReturnAddress(0x1202); 599 regs_.FakeSetReturnAddressValid(true); 600 601 ElfInterfaceFake::FakePushStepData(StepData(0x23102, 0x10020, false)); 602 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 603 604 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 605 unwinder.Unwind(); 606 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 607 608 ASSERT_EQ(3U, unwinder.NumFrames()); 609 610 auto* frame = &unwinder.frames()[0]; 611 EXPECT_EQ(0U, frame->num); 612 EXPECT_EQ(0U, frame->rel_pc); 613 EXPECT_EQ(0U, frame->pc); 614 EXPECT_EQ(0x10000U, frame->sp); 615 EXPECT_EQ("", frame->function_name); 616 EXPECT_EQ(0U, frame->function_offset); 617 EXPECT_EQ("", frame->map_name); 618 EXPECT_EQ(0U, frame->map_offset); 619 EXPECT_EQ(0U, frame->map_start); 620 EXPECT_EQ(0U, frame->map_end); 621 EXPECT_EQ(0U, frame->map_load_bias); 622 EXPECT_EQ(0, frame->map_flags); 623 624 frame = &unwinder.frames()[1]; 625 EXPECT_EQ(1U, frame->num); 626 EXPECT_EQ(0x200U, frame->rel_pc); 627 EXPECT_EQ(0x1200U, frame->pc); 628 EXPECT_EQ(0x10000U, frame->sp); 629 EXPECT_EQ("Frame0", frame->function_name); 630 EXPECT_EQ(0U, frame->function_offset); 631 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 632 EXPECT_EQ(0U, frame->map_offset); 633 EXPECT_EQ(0x1000U, frame->map_start); 634 EXPECT_EQ(0x8000U, frame->map_end); 635 EXPECT_EQ(0U, frame->map_load_bias); 636 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 637 638 frame = &unwinder.frames()[2]; 639 EXPECT_EQ(2U, frame->num); 640 EXPECT_EQ(0x100U, frame->rel_pc); 641 EXPECT_EQ(0x23100U, frame->pc); 642 EXPECT_EQ(0x10020U, frame->sp); 643 EXPECT_EQ("Frame1", frame->function_name); 644 EXPECT_EQ(1U, frame->function_offset); 645 EXPECT_EQ("/fake/libanother.so", frame->map_name); 646 EXPECT_EQ(0U, frame->map_offset); 647 EXPECT_EQ(0x23000U, frame->map_start); 648 EXPECT_EQ(0x24000U, frame->map_end); 649 EXPECT_EQ(0U, frame->map_load_bias); 650 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 651} 652 653// Verify that a speculative frame is added then removed because no other 654// frames are added. 655TEST_F(UnwinderTest, speculative_frame_removed) { 656 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 657 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1)); 658 659 // Fake as if code called a nullptr function. 660 regs_.set_pc(0); 661 regs_.set_sp(0x10000); 662 regs_.FakeSetReturnAddress(0x1202); 663 regs_.FakeSetReturnAddressValid(true); 664 665 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 666 unwinder.Unwind(); 667 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 668 669 ASSERT_EQ(1U, unwinder.NumFrames()); 670 671 auto* frame = &unwinder.frames()[0]; 672 EXPECT_EQ(0U, frame->num); 673 EXPECT_EQ(0U, frame->rel_pc); 674 EXPECT_EQ(0U, frame->pc); 675 EXPECT_EQ(0x10000U, frame->sp); 676 EXPECT_EQ("", frame->function_name); 677 EXPECT_EQ(0U, frame->function_offset); 678 EXPECT_EQ("", frame->map_name); 679 EXPECT_EQ(0U, frame->map_offset); 680 EXPECT_EQ(0U, frame->map_start); 681 EXPECT_EQ(0U, frame->map_end); 682 EXPECT_EQ(0U, frame->map_load_bias); 683 EXPECT_EQ(0, frame->map_flags); 684} 685 686// Verify that an unwind stops when a frame is in given suffix. 687TEST_F(UnwinderTest, map_ignore_suffixes) { 688 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 689 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1)); 690 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2)); 691 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame3", 3)); 692 693 // Fake as if code called a nullptr function. 694 regs_.set_pc(0x1000); 695 regs_.set_sp(0x10000); 696 ElfInterfaceFake::FakePushStepData(StepData(0x43402, 0x10010, false)); 697 ElfInterfaceFake::FakePushStepData(StepData(0x53502, 0x10020, false)); 698 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 699 700 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 701 std::vector<std::string> suffixes{"oat"}; 702 unwinder.Unwind(nullptr, &suffixes); 703 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 704 705 ASSERT_EQ(2U, unwinder.NumFrames()); 706 // Make sure the elf was not initialized. 707 MapInfo* map_info = maps_.Find(0x53000); 708 ASSERT_TRUE(map_info != nullptr); 709 EXPECT_TRUE(map_info->elf == nullptr); 710 711 auto* frame = &unwinder.frames()[0]; 712 EXPECT_EQ(0U, frame->num); 713 EXPECT_EQ(0U, frame->rel_pc); 714 EXPECT_EQ(0x1000U, frame->pc); 715 EXPECT_EQ(0x10000U, frame->sp); 716 EXPECT_EQ("Frame0", frame->function_name); 717 EXPECT_EQ(0U, frame->function_offset); 718 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 719 EXPECT_EQ(0U, frame->map_offset); 720 EXPECT_EQ(0x1000U, frame->map_start); 721 EXPECT_EQ(0x8000U, frame->map_end); 722 EXPECT_EQ(0U, frame->map_load_bias); 723 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 724 725 frame = &unwinder.frames()[1]; 726 EXPECT_EQ(1U, frame->num); 727 EXPECT_EQ(0x400U, frame->rel_pc); 728 EXPECT_EQ(0x43400U, frame->pc); 729 EXPECT_EQ(0x10010U, frame->sp); 730 EXPECT_EQ("Frame1", frame->function_name); 731 EXPECT_EQ(1U, frame->function_offset); 732 EXPECT_EQ("/fake/fake.apk", frame->map_name); 733 EXPECT_EQ(0x1d000U, frame->map_offset); 734 EXPECT_EQ(0x43000U, frame->map_start); 735 EXPECT_EQ(0x44000U, frame->map_end); 736 EXPECT_EQ(0U, frame->map_load_bias); 737 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 738} 739 740// Verify that an unwind stops when the sp and pc don't change. 741TEST_F(UnwinderTest, sp_pc_do_not_change) { 742 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 743 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1)); 744 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame2", 2)); 745 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame3", 3)); 746 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame4", 4)); 747 748 regs_.set_pc(0x1000); 749 regs_.set_sp(0x10000); 750 ElfInterfaceFake::FakePushStepData(StepData(0x33402, 0x10010, false)); 751 ElfInterfaceFake::FakePushStepData(StepData(0x33502, 0x10020, false)); 752 ElfInterfaceFake::FakePushStepData(StepData(0x33502, 0x10020, false)); 753 ElfInterfaceFake::FakePushStepData(StepData(0x33502, 0x10020, false)); 754 ElfInterfaceFake::FakePushStepData(StepData(0x33502, 0x10020, false)); 755 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 756 757 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 758 unwinder.Unwind(); 759 EXPECT_EQ(ERROR_REPEATED_FRAME, unwinder.LastErrorCode()); 760 761 ASSERT_EQ(3U, unwinder.NumFrames()); 762 763 auto* frame = &unwinder.frames()[0]; 764 EXPECT_EQ(0U, frame->num); 765 EXPECT_EQ(0U, frame->rel_pc); 766 EXPECT_EQ(0x1000U, frame->pc); 767 EXPECT_EQ(0x10000U, frame->sp); 768 EXPECT_EQ("Frame0", frame->function_name); 769 EXPECT_EQ(0U, frame->function_offset); 770 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 771 EXPECT_EQ(0U, frame->map_offset); 772 EXPECT_EQ(0x1000U, frame->map_start); 773 EXPECT_EQ(0x8000U, frame->map_end); 774 EXPECT_EQ(0U, frame->map_load_bias); 775 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 776 777 frame = &unwinder.frames()[1]; 778 EXPECT_EQ(1U, frame->num); 779 EXPECT_EQ(0x400U, frame->rel_pc); 780 EXPECT_EQ(0x33400U, frame->pc); 781 EXPECT_EQ(0x10010U, frame->sp); 782 EXPECT_EQ("Frame1", frame->function_name); 783 EXPECT_EQ(1U, frame->function_offset); 784 EXPECT_EQ("/fake/compressed.so", frame->map_name); 785 EXPECT_EQ(0U, frame->map_offset); 786 EXPECT_EQ(0x33000U, frame->map_start); 787 EXPECT_EQ(0x34000U, frame->map_end); 788 EXPECT_EQ(0U, frame->map_load_bias); 789 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 790 791 frame = &unwinder.frames()[2]; 792 EXPECT_EQ(2U, frame->num); 793 EXPECT_EQ(0x500U, frame->rel_pc); 794 EXPECT_EQ(0x33500U, frame->pc); 795 EXPECT_EQ(0x10020U, frame->sp); 796 EXPECT_EQ("Frame2", frame->function_name); 797 EXPECT_EQ(2U, frame->function_offset); 798 EXPECT_EQ("/fake/compressed.so", frame->map_name); 799 EXPECT_EQ(0U, frame->map_offset); 800 EXPECT_EQ(0x33000U, frame->map_start); 801 EXPECT_EQ(0x34000U, frame->map_end); 802 EXPECT_EQ(0U, frame->map_load_bias); 803 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 804} 805 806TEST_F(UnwinderTest, dex_pc_in_map) { 807 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 808 regs_.set_pc(0x1000); 809 regs_.set_sp(0x10000); 810 regs_.FakeSetDexPc(0xa3400); 811 812 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 813 unwinder.Unwind(); 814 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 815 816 ASSERT_EQ(2U, unwinder.NumFrames()); 817 818 auto* frame = &unwinder.frames()[0]; 819 EXPECT_EQ(0U, frame->num); 820 EXPECT_EQ(0x400U, frame->rel_pc); 821 EXPECT_EQ(0xa3400U, frame->pc); 822 EXPECT_EQ(0x10000U, frame->sp); 823 EXPECT_EQ("", frame->function_name); 824 EXPECT_EQ(0U, frame->function_offset); 825 EXPECT_EQ("/fake/fake.vdex", frame->map_name); 826 EXPECT_EQ(0U, frame->map_offset); 827 EXPECT_EQ(0xa3000U, frame->map_start); 828 EXPECT_EQ(0xa4000U, frame->map_end); 829 EXPECT_EQ(0U, frame->map_load_bias); 830 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags); 831 832 frame = &unwinder.frames()[1]; 833 EXPECT_EQ(1U, frame->num); 834 EXPECT_EQ(0U, frame->rel_pc); 835 EXPECT_EQ(0x1000U, frame->pc); 836 EXPECT_EQ(0x10000U, frame->sp); 837 EXPECT_EQ("Frame0", frame->function_name); 838 EXPECT_EQ(0U, frame->function_offset); 839 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 840 EXPECT_EQ(0U, frame->map_offset); 841 EXPECT_EQ(0x1000U, frame->map_start); 842 EXPECT_EQ(0x8000U, frame->map_end); 843 EXPECT_EQ(0U, frame->map_load_bias); 844 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 845} 846 847TEST_F(UnwinderTest, dex_pc_not_in_map) { 848 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 849 regs_.set_pc(0x1000); 850 regs_.set_sp(0x10000); 851 regs_.FakeSetDexPc(0x50000); 852 853 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 854 unwinder.Unwind(); 855 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 856 857 ASSERT_EQ(2U, unwinder.NumFrames()); 858 859 auto* frame = &unwinder.frames()[0]; 860 EXPECT_EQ(0U, frame->num); 861 EXPECT_EQ(0x50000U, frame->rel_pc); 862 EXPECT_EQ(0x50000U, frame->pc); 863 EXPECT_EQ(0x10000U, frame->sp); 864 EXPECT_EQ("", frame->function_name); 865 EXPECT_EQ(0U, frame->function_offset); 866 EXPECT_EQ("", frame->map_name); 867 EXPECT_EQ(0U, frame->map_offset); 868 EXPECT_EQ(0U, frame->map_start); 869 EXPECT_EQ(0U, frame->map_end); 870 EXPECT_EQ(0U, frame->map_load_bias); 871 EXPECT_EQ(0, frame->map_flags); 872 873 frame = &unwinder.frames()[1]; 874 EXPECT_EQ(1U, frame->num); 875 EXPECT_EQ(0U, frame->rel_pc); 876 EXPECT_EQ(0x1000U, frame->pc); 877 EXPECT_EQ(0x10000U, frame->sp); 878 EXPECT_EQ("Frame0", frame->function_name); 879 EXPECT_EQ(0U, frame->function_offset); 880 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 881 EXPECT_EQ(0U, frame->map_offset); 882 EXPECT_EQ(0x1000U, frame->map_start); 883 EXPECT_EQ(0x8000U, frame->map_end); 884 EXPECT_EQ(0U, frame->map_load_bias); 885 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 886} 887 888TEST_F(UnwinderTest, dex_pc_multiple_frames) { 889 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 0)); 890 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame1", 1)); 891 regs_.set_pc(0x1000); 892 regs_.set_sp(0x10000); 893 regs_.FakeSetDexPc(0xa3400); 894 ElfInterfaceFake::FakePushStepData(StepData(0x33402, 0x10010, false)); 895 ElfInterfaceFake::FakePushStepData(StepData(0, 0, true)); 896 897 Unwinder unwinder(64, &maps_, ®s_, process_memory_); 898 unwinder.Unwind(); 899 EXPECT_EQ(ERROR_NONE, unwinder.LastErrorCode()); 900 901 ASSERT_EQ(3U, unwinder.NumFrames()); 902 903 auto* frame = &unwinder.frames()[0]; 904 EXPECT_EQ(0U, frame->num); 905 EXPECT_EQ(0x400U, frame->rel_pc); 906 EXPECT_EQ(0xa3400U, frame->pc); 907 EXPECT_EQ(0x10000U, frame->sp); 908 EXPECT_EQ("", frame->function_name); 909 EXPECT_EQ(0U, frame->function_offset); 910 EXPECT_EQ("/fake/fake.vdex", frame->map_name); 911 EXPECT_EQ(0U, frame->map_offset); 912 EXPECT_EQ(0xa3000U, frame->map_start); 913 EXPECT_EQ(0xa4000U, frame->map_end); 914 EXPECT_EQ(0U, frame->map_load_bias); 915 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, frame->map_flags); 916 917 frame = &unwinder.frames()[1]; 918 EXPECT_EQ(1U, frame->num); 919 EXPECT_EQ(0U, frame->rel_pc); 920 EXPECT_EQ(0x1000U, frame->pc); 921 EXPECT_EQ(0x10000U, frame->sp); 922 EXPECT_EQ("Frame0", frame->function_name); 923 EXPECT_EQ(0U, frame->function_offset); 924 EXPECT_EQ("/system/fake/libc.so", frame->map_name); 925 EXPECT_EQ(0U, frame->map_offset); 926 EXPECT_EQ(0x1000U, frame->map_start); 927 EXPECT_EQ(0x8000U, frame->map_end); 928 EXPECT_EQ(0U, frame->map_load_bias); 929 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 930 931 frame = &unwinder.frames()[2]; 932 EXPECT_EQ(2U, frame->num); 933 EXPECT_EQ(0x400U, frame->rel_pc); 934 EXPECT_EQ(0x33400U, frame->pc); 935 EXPECT_EQ(0x10010U, frame->sp); 936 EXPECT_EQ("Frame1", frame->function_name); 937 EXPECT_EQ(1U, frame->function_offset); 938 EXPECT_EQ("/fake/compressed.so", frame->map_name); 939 EXPECT_EQ(0U, frame->map_offset); 940 EXPECT_EQ(0x33000U, frame->map_start); 941 EXPECT_EQ(0x34000U, frame->map_end); 942 EXPECT_EQ(0U, frame->map_load_bias); 943 EXPECT_EQ(PROT_READ | PROT_WRITE, frame->map_flags); 944} 945 946// Verify format frame code. 947TEST_F(UnwinderTest, format_frame_static) { 948 FrameData frame; 949 frame.num = 1; 950 frame.rel_pc = 0x1000; 951 frame.pc = 0x4000; 952 frame.sp = 0x1000; 953 frame.function_name = "function"; 954 frame.function_offset = 100; 955 frame.map_name = "/fake/libfake.so"; 956 frame.map_offset = 0x2000; 957 frame.map_start = 0x3000; 958 frame.map_end = 0x6000; 959 frame.map_flags = PROT_READ; 960 961 EXPECT_EQ(" #01 pc 0000000000001000 (offset 0x2000) /fake/libfake.so (function+100)", 962 Unwinder::FormatFrame(frame, false)); 963 EXPECT_EQ(" #01 pc 00001000 (offset 0x2000) /fake/libfake.so (function+100)", 964 Unwinder::FormatFrame(frame, true)); 965 966 frame.map_offset = 0; 967 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so (function+100)", 968 Unwinder::FormatFrame(frame, false)); 969 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (function+100)", 970 Unwinder::FormatFrame(frame, true)); 971 972 frame.function_offset = 0; 973 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so (function)", 974 Unwinder::FormatFrame(frame, false)); 975 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so (function)", Unwinder::FormatFrame(frame, true)); 976 977 frame.function_name = ""; 978 EXPECT_EQ(" #01 pc 0000000000001000 /fake/libfake.so", Unwinder::FormatFrame(frame, false)); 979 EXPECT_EQ(" #01 pc 00001000 /fake/libfake.so", Unwinder::FormatFrame(frame, true)); 980 981 frame.map_name = ""; 982 EXPECT_EQ(" #01 pc 0000000000001000 <anonymous:3000>", Unwinder::FormatFrame(frame, false)); 983 EXPECT_EQ(" #01 pc 00001000 <anonymous:3000>", Unwinder::FormatFrame(frame, true)); 984 985 frame.map_start = 0; 986 frame.map_end = 0; 987 EXPECT_EQ(" #01 pc 0000000000001000 <unknown>", Unwinder::FormatFrame(frame, false)); 988 EXPECT_EQ(" #01 pc 00001000 <unknown>", Unwinder::FormatFrame(frame, true)); 989} 990 991static std::string ArchToString(ArchEnum arch) { 992 if (arch == ARCH_ARM) { 993 return "Arm"; 994 } else if (arch == ARCH_ARM64) { 995 return "Arm64"; 996 } else if (arch == ARCH_X86) { 997 return "X86"; 998 } else if (arch == ARCH_X86_64) { 999 return "X86_64"; 1000 } else { 1001 return "Unknown"; 1002 } 1003} 1004 1005// Verify format frame code. 1006TEST_F(UnwinderTest, format_frame) { 1007 std::vector<Regs*> reg_list; 1008 RegsArm* arm = new RegsArm; 1009 arm->set_pc(0x2300); 1010 arm->set_sp(0x10000); 1011 reg_list.push_back(arm); 1012 1013 RegsArm64* arm64 = new RegsArm64; 1014 arm64->set_pc(0x2300); 1015 arm64->set_sp(0x10000); 1016 reg_list.push_back(arm64); 1017 1018 RegsX86* x86 = new RegsX86; 1019 x86->set_pc(0x2300); 1020 x86->set_sp(0x10000); 1021 reg_list.push_back(x86); 1022 1023 RegsX86_64* x86_64 = new RegsX86_64; 1024 x86_64->set_pc(0x2300); 1025 x86_64->set_sp(0x10000); 1026 reg_list.push_back(x86_64); 1027 1028 RegsMips* mips = new RegsMips; 1029 mips->set_pc(0x2300); 1030 mips->set_sp(0x10000); 1031 reg_list.push_back(mips); 1032 1033 RegsMips64* mips64 = new RegsMips64; 1034 mips64->set_pc(0x2300); 1035 mips64->set_sp(0x10000); 1036 reg_list.push_back(mips64); 1037 1038 for (auto regs : reg_list) { 1039 ElfInterfaceFake::FakePushFunctionData(FunctionData("Frame0", 10)); 1040 1041 Unwinder unwinder(64, &maps_, regs, process_memory_); 1042 unwinder.Unwind(); 1043 1044 ASSERT_EQ(1U, unwinder.NumFrames()); 1045 std::string expected; 1046 switch (regs->Arch()) { 1047 case ARCH_ARM: 1048 case ARCH_X86: 1049 case ARCH_MIPS: 1050 expected = " #00 pc 00001300 /system/fake/libc.so (Frame0+10)"; 1051 break; 1052 case ARCH_ARM64: 1053 case ARCH_X86_64: 1054 case ARCH_MIPS64: 1055 expected = " #00 pc 0000000000001300 /system/fake/libc.so (Frame0+10)"; 1056 break; 1057 default: 1058 expected = ""; 1059 } 1060 EXPECT_EQ(expected, unwinder.FormatFrame(0)) 1061 << "Mismatch of frame format for regs arch " << ArchToString(regs->Arch()); 1062 delete regs; 1063 } 1064} 1065 1066} // namespace unwindstack 1067