path: root/libunwindstack/tests/DwarfCfaLogTest.cpp

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdint.h>

#include <memory>
#include <type_traits>
#include <unordered_map>

#include <android-base/stringprintf.h>
#include <gtest/gtest.h>

#include <unwindstack/DwarfLocation.h>
#include <unwindstack/DwarfMemory.h>
#include <unwindstack/DwarfStructs.h>
#include <unwindstack/Log.h>

#include "DwarfCfa.h"

#include "LogFake.h"
#include "MemoryFake.h"

namespace unwindstack {

template <typename TypeParam>
class DwarfCfaLogTest : public ::testing::Test {
 protected:
  void SetUp() override {
    ResetLogs();
    memory_.Clear();

    dmem_.reset(new DwarfMemory(&memory_));

    cie_.cfa_instructions_offset = 0x1000;
    cie_.cfa_instructions_end = 0x1030;
    // These two values should be different to distinguish between
    // operations that deal with code versus data.
    cie_.code_alignment_factor = 4;
    cie_.data_alignment_factor = 8;

    fde_.cfa_instructions_offset = 0x2000;
    fde_.cfa_instructions_end = 0x2030;
    fde_.pc_start = 0x2000;
    fde_.pc_end = 0x2000;
    fde_.pc_end = 0x10000;
    fde_.cie = &cie_;
    cfa_.reset(new DwarfCfa<TypeParam>(dmem_.get(), &fde_));
  }

  MemoryFake memory_;
  std::unique_ptr<DwarfMemory> dmem_;
  std::unique_ptr<DwarfCfa<TypeParam>> cfa_;
  DwarfCie cie_;
  DwarfFde fde_;
};
TYPED_TEST_CASE_P(DwarfCfaLogTest);

// NOTE: All class variable references have to be prefaced with this->.

TYPED_TEST_P(DwarfCfaLogTest, cfa_illegal) {
  for (uint8_t i = 0x17; i < 0x3f; i++) {
    if (i == 0x2e || i == 0x2f) {
      // Skip gnu extension ops.
      continue;
    }
    this->memory_.SetMemory(0x2000, std::vector<uint8_t>{i});

    ResetLogs();
    ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x2000, 0x2001));
    std::string expected = "4 unwind Illegal\n";
    expected += android::base::StringPrintf("4 unwind Raw Data: 0x%02x\n", i);
    ASSERT_EQ(expected, GetFakeLogPrint());
    ASSERT_EQ("", GetFakeLogBuf());
  }
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_nop) {
  this->memory_.SetMemory(0x2000, std::vector<uint8_t>{0x00});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x2000, 0x2001));
  std::string expected =
      "4 unwind DW_CFA_nop\n"
      "4 unwind Raw Data: 0x00\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_offset) {
  this->memory_.SetMemory(0x2000, std::vector<uint8_t>{0x83, 0x04});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x2000, 0x2002));
  std::string expected =
      "4 unwind DW_CFA_offset register(3) 4\n"
      "4 unwind Raw Data: 0x83 0x04\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x2100, std::vector<uint8_t>{0x83, 0x84, 0x01});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x2100, 0x2103));
  expected =
      "4 unwind DW_CFA_offset register(3) 132\n"
      "4 unwind Raw Data: 0x83 0x84 0x01\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_offset_extended) {
  this->memory_.SetMemory(0x500, std::vector<uint8_t>{0x05, 0x03, 0x02});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x500, 0x503));
  std::string expected =
      "4 unwind DW_CFA_offset_extended register(3) 2\n"
      "4 unwind Raw Data: 0x05 0x03 0x02\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x1500, std::vector<uint8_t>{0x05, 0x81, 0x01, 0x82, 0x12});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x1500, 0x1505));
  expected =
      "4 unwind DW_CFA_offset_extended register(129) 2306\n"
      "4 unwind Raw Data: 0x05 0x81 0x01 0x82 0x12\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_offset_extended_sf) {
  this->memory_.SetMemory(0x500, std::vector<uint8_t>{0x11, 0x05, 0x10});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x500, 0x503));
  std::string expected =
      "4 unwind DW_CFA_offset_extended_sf register(5) 16\n"
      "4 unwind Raw Data: 0x11 0x05 0x10\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  // Check a negative value for the offset.
  ResetLogs();
  this->memory_.SetMemory(0x1500, std::vector<uint8_t>{0x11, 0x86, 0x01, 0xff, 0x7f});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x1500, 0x1505));
  expected =
      "4 unwind DW_CFA_offset_extended_sf register(134) -1\n"
      "4 unwind Raw Data: 0x11 0x86 0x01 0xff 0x7f\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_restore) {
  this->memory_.SetMemory(0x2000, std::vector<uint8_t>{0xc2});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x2000, 0x2001));
  std::string expected =
      "4 unwind DW_CFA_restore register(2)\n"
      "4 unwind Raw Data: 0xc2\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x3000, std::vector<uint8_t>{0x82, 0x04, 0xc2});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x3000, 0x3003));
  expected =
      "4 unwind DW_CFA_offset register(2) 4\n"
      "4 unwind Raw Data: 0x82 0x04\n"
      "4 unwind DW_CFA_restore register(2)\n"
      "4 unwind Raw Data: 0xc2\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_restore_extended) {
  this->memory_.SetMemory(0x4000, std::vector<uint8_t>{0x06, 0x08});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x4000, 0x4002));
  std::string expected =
      "4 unwind DW_CFA_restore_extended register(8)\n"
      "4 unwind Raw Data: 0x06 0x08\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x5000, std::vector<uint8_t>{0x05, 0x82, 0x02, 0x04, 0x06, 0x82, 0x02});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x5000, 0x5007));
  expected =
      "4 unwind DW_CFA_offset_extended register(258) 4\n"
      "4 unwind Raw Data: 0x05 0x82 0x02 0x04\n"
      "4 unwind DW_CFA_restore_extended register(258)\n"
      "4 unwind Raw Data: 0x06 0x82 0x02\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_set_loc) {
  uint8_t buffer[1 + sizeof(TypeParam)];
  buffer[0] = 0x1;
  TypeParam address;
  std::string raw_data("Raw Data: 0x01 ");
  std::string address_str;
  if (std::is_same<TypeParam, uint32_t>::value) {
    address = 0x81234578U;
    address_str = "0x81234578";
    raw_data += "0x78 0x45 0x23 0x81";
  } else {
    address = 0x8123456712345678ULL;
    address_str = "0x8123456712345678";
    raw_data += "0x78 0x56 0x34 0x12 0x67 0x45 0x23 0x81";
  }
  memcpy(&buffer[1], &address, sizeof(address));

  this->memory_.SetMemory(0x50, buffer, sizeof(buffer));
  ResetLogs();

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x50, 0x51 + sizeof(TypeParam)));
  std::string expected = "4 unwind DW_CFA_set_loc " + address_str + "\n";
  expected += "4 unwind " + raw_data + "\n";
  expected += "4 unwind \n";
  expected += "4 unwind PC " + address_str + "\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  // Check for a set going back.
  ResetLogs();
  this->fde_.pc_start = address + 0x10;

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x50, 0x51 + sizeof(TypeParam)));
  expected = "4 unwind DW_CFA_set_loc " + address_str + "\n";
  expected += "4 unwind " + raw_data + "\n";
  expected += "4 unwind \n";
  expected += "4 unwind PC " + address_str + "\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_advance_loc) {
  this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x44});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x200, 0x201));
  std::string expected =
      "4 unwind DW_CFA_advance_loc 4\n"
      "4 unwind Raw Data: 0x44\n"
      "4 unwind \n"
      "4 unwind PC 0x2010\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x200, 0x201));
  expected =
      "4 unwind DW_CFA_advance_loc 4\n"
      "4 unwind Raw Data: 0x44\n"
      "4 unwind \n"
      "4 unwind PC 0x2110\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_advance_loc1) {
  this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x02, 0x04});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x200, 0x202));
  std::string expected =
      "4 unwind DW_CFA_advance_loc1 4\n"
      "4 unwind Raw Data: 0x02 0x04\n"
      "4 unwind \n"
      "4 unwind PC 0x2004\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x10, 0x200, 0x202));
  expected =
      "4 unwind DW_CFA_advance_loc1 4\n"
      "4 unwind Raw Data: 0x02 0x04\n"
      "4 unwind \n"
      "4 unwind PC 0x2014\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_advance_loc2) {
  this->memory_.SetMemory(0x600, std::vector<uint8_t>{0x03, 0x04, 0x03});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x600, 0x603));
  std::string expected =
      "4 unwind DW_CFA_advance_loc2 772\n"
      "4 unwind Raw Data: 0x03 0x04 0x03\n"
      "4 unwind \n"
      "4 unwind PC 0x2304\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x1000, 0x600, 0x603));
  expected =
      "4 unwind DW_CFA_advance_loc2 772\n"
      "4 unwind Raw Data: 0x03 0x04 0x03\n"
      "4 unwind \n"
      "4 unwind PC 0x3304\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_advance_loc4) {
  this->memory_.SetMemory(0x500, std::vector<uint8_t>{0x04, 0x04, 0x03, 0x02, 0x01});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x500, 0x505));
  std::string expected =
      "4 unwind DW_CFA_advance_loc4 16909060\n"
      "4 unwind Raw Data: 0x04 0x04 0x03 0x02 0x01\n"
      "4 unwind \n"
      "4 unwind PC 0x1022304\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x2000, 0x500, 0x505));
  expected =
      "4 unwind DW_CFA_advance_loc4 16909060\n"
      "4 unwind Raw Data: 0x04 0x04 0x03 0x02 0x01\n"
      "4 unwind \n"
      "4 unwind PC 0x1024304\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_undefined) {
  this->memory_.SetMemory(0xa00, std::vector<uint8_t>{0x07, 0x09});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0xa00, 0xa02));
  std::string expected =
      "4 unwind DW_CFA_undefined register(9)\n"
      "4 unwind Raw Data: 0x07 0x09\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  dwarf_loc_regs_t cie_loc_regs;
  this->memory_.SetMemory(0x1a00, std::vector<uint8_t>{0x07, 0x81, 0x01});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x1a00, 0x1a03));
  expected =
      "4 unwind DW_CFA_undefined register(129)\n"
      "4 unwind Raw Data: 0x07 0x81 0x01\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_same) {
  this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x08, 0x7f});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x102));
  std::string expected =
      "4 unwind DW_CFA_same_value register(127)\n"
      "4 unwind Raw Data: 0x08 0x7f\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x2100, std::vector<uint8_t>{0x08, 0xff, 0x01});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x2100, 0x2103));
  expected =
      "4 unwind DW_CFA_same_value register(255)\n"
      "4 unwind Raw Data: 0x08 0xff 0x01\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_register) {
  this->memory_.SetMemory(0x300, std::vector<uint8_t>{0x09, 0x02, 0x01});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x300, 0x303));
  std::string expected =
      "4 unwind DW_CFA_register register(2) register(1)\n"
      "4 unwind Raw Data: 0x09 0x02 0x01\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x4300, std::vector<uint8_t>{0x09, 0xff, 0x01, 0xff, 0x03});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x4300, 0x4305));
  expected =
      "4 unwind DW_CFA_register register(255) register(511)\n"
      "4 unwind Raw Data: 0x09 0xff 0x01 0xff 0x03\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_state) {
  this->memory_.SetMemory(0x300, std::vector<uint8_t>{0x0a});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x300, 0x301));

  std::string expected =
      "4 unwind DW_CFA_remember_state\n"
      "4 unwind Raw Data: 0x0a\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x4300, std::vector<uint8_t>{0x0b});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x4300, 0x4301));

  expected =
      "4 unwind DW_CFA_restore_state\n"
      "4 unwind Raw Data: 0x0b\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_state_cfa_offset_restore) {
  this->memory_.SetMemory(0x3000, std::vector<uint8_t>{0x0a, 0x0e, 0x40, 0x0b});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x3000, 0x3004));

  std::string expected =
      "4 unwind DW_CFA_remember_state\n"
      "4 unwind Raw Data: 0x0a\n"
      "4 unwind DW_CFA_def_cfa_offset 64\n"
      "4 unwind Raw Data: 0x0e 0x40\n"
      "4 unwind DW_CFA_restore_state\n"
      "4 unwind Raw Data: 0x0b\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_def_cfa) {
  this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x0c, 0x7f, 0x74});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x103));

  std::string expected =
      "4 unwind DW_CFA_def_cfa register(127) 116\n"
      "4 unwind Raw Data: 0x0c 0x7f 0x74\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x0c, 0xff, 0x02, 0xf4, 0x04});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x200, 0x205));

  expected =
      "4 unwind DW_CFA_def_cfa register(383) 628\n"
      "4 unwind Raw Data: 0x0c 0xff 0x02 0xf4 0x04\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_def_cfa_sf) {
  this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x12, 0x30, 0x25});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x103));

  std::string expected =
      "4 unwind DW_CFA_def_cfa_sf register(48) 37\n"
      "4 unwind Raw Data: 0x12 0x30 0x25\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  // Test a negative value.
  ResetLogs();
  this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x12, 0xa3, 0x01, 0xfa, 0x7f});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x200, 0x205));

  expected =
      "4 unwind DW_CFA_def_cfa_sf register(163) -6\n"
      "4 unwind Raw Data: 0x12 0xa3 0x01 0xfa 0x7f\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_def_cfa_register) {
  this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x0d, 0x72});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x102));

  std::string expected =
      "4 unwind DW_CFA_def_cfa_register register(114)\n"
      "4 unwind Raw Data: 0x0d 0x72\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x0d, 0xf9, 0x20});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x200, 0x203));

  expected =
      "4 unwind DW_CFA_def_cfa_register register(4217)\n"
      "4 unwind Raw Data: 0x0d 0xf9 0x20\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_def_cfa_offset) {
  this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x0e, 0x59});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x102));

  std::string expected =
      "4 unwind DW_CFA_def_cfa_offset 89\n"
      "4 unwind Raw Data: 0x0e 0x59\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x102));

  expected =
      "4 unwind DW_CFA_def_cfa_offset 89\n"
      "4 unwind Raw Data: 0x0e 0x59\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x0e, 0xd4, 0x0a});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x200, 0x203));

  expected =
      "4 unwind DW_CFA_def_cfa_offset 1364\n"
      "4 unwind Raw Data: 0x0e 0xd4 0x0a\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_def_cfa_offset_sf) {
  this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x13, 0x23});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x102));

  std::string expected =
      "4 unwind DW_CFA_def_cfa_offset_sf 35\n"
      "4 unwind Raw Data: 0x13 0x23\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x102));

  expected =
      "4 unwind DW_CFA_def_cfa_offset_sf 35\n"
      "4 unwind Raw Data: 0x13 0x23\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  // Negative offset.
  ResetLogs();
  this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x13, 0xf6, 0x7f});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x200, 0x203));

  expected =
      "4 unwind DW_CFA_def_cfa_offset_sf -10\n"
      "4 unwind Raw Data: 0x13 0xf6 0x7f\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_def_cfa_expression) {
  this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x0f, 0x04, 0x01, 0x02, 0x04, 0x05});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x106));

  std::string expected =
      "4 unwind DW_CFA_def_cfa_expression 4\n"
      "4 unwind Raw Data: 0x0f 0x04 0x01 0x02 0x04 0x05\n"
      "4 unwind   Illegal\n"
      "4 unwind   Raw Data: 0x01\n"
      "4 unwind   Illegal\n"
      "4 unwind   Raw Data: 0x02\n"
      "4 unwind   Illegal\n"
      "4 unwind   Raw Data: 0x04\n"
      "4 unwind   Illegal\n"
      "4 unwind   Raw Data: 0x05\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  std::vector<uint8_t> ops{0x0f, 0x81, 0x01};
  expected = "4 unwind Raw Data: 0x0f 0x81 0x01";
  std::string op_string;
  for (uint8_t i = 3; i < 132; i++) {
    ops.push_back(0x05);
    op_string +=
        "4 unwind   Illegal\n"
        "4 unwind   Raw Data: 0x05\n";
    expected += " 0x05";
    if (((i + 1) % 10) == 0) {
      expected += "\n4 unwind Raw Data:";
    }
  }
  expected += '\n';
  this->memory_.SetMemory(0x200, ops);
  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x200, 0x284));

  expected = "4 unwind DW_CFA_def_cfa_expression 129\n" + expected;
  ASSERT_EQ(expected + op_string, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_expression) {
  this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x10, 0x04, 0x02, 0xc0, 0xc1});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x105));

  std::string expected =
      "4 unwind DW_CFA_expression register(4) 2\n"
      "4 unwind Raw Data: 0x10 0x04 0x02 0xc0 0xc1\n"
      "4 unwind   Illegal\n"
      "4 unwind   Raw Data: 0xc0\n"
      "4 unwind   Illegal\n"
      "4 unwind   Raw Data: 0xc1\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  std::vector<uint8_t> ops{0x10, 0xff, 0x01, 0x82, 0x01};
  expected = "4 unwind Raw Data: 0x10 0xff 0x01 0x82 0x01";
  std::string op_string;
  for (uint8_t i = 5; i < 135; i++) {
    ops.push_back(0xa0 + (i - 5) % 96);
    op_string += "4 unwind   Illegal\n";
    op_string += android::base::StringPrintf("4 unwind   Raw Data: 0x%02x\n", ops.back());
    expected += android::base::StringPrintf(" 0x%02x", ops.back());
    if (((i + 1) % 10) == 0) {
      expected += "\n4 unwind Raw Data:";
    }
  }
  expected = "4 unwind DW_CFA_expression register(255) 130\n" + expected + "\n";

  this->memory_.SetMemory(0x200, ops);
  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x200, 0x287));

  ASSERT_EQ(expected + op_string, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_val_offset) {
  this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x14, 0x45, 0x54});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x103));

  std::string expected =
      "4 unwind DW_CFA_val_offset register(69) 84\n"
      "4 unwind Raw Data: 0x14 0x45 0x54\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x400, std::vector<uint8_t>{0x14, 0xa2, 0x02, 0xb4, 0x05});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x400, 0x405));

  expected =
      "4 unwind DW_CFA_val_offset register(290) 692\n"
      "4 unwind Raw Data: 0x14 0xa2 0x02 0xb4 0x05\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_val_offset_sf) {
  this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x15, 0x56, 0x12});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x103));

  std::string expected =
      "4 unwind DW_CFA_val_offset_sf register(86) 18\n"
      "4 unwind Raw Data: 0x15 0x56 0x12\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  // Negative value.
  ResetLogs();
  this->memory_.SetMemory(0xa00, std::vector<uint8_t>{0x15, 0xff, 0x01, 0xc0, 0x7f});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0xa00, 0xa05));

  expected =
      "4 unwind DW_CFA_val_offset_sf register(255) -64\n"
      "4 unwind Raw Data: 0x15 0xff 0x01 0xc0 0x7f\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_val_expression) {
  this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x16, 0x05, 0x02, 0xb0, 0xb1});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x100, 0x105));

  std::string expected =
      "4 unwind DW_CFA_val_expression register(5) 2\n"
      "4 unwind Raw Data: 0x16 0x05 0x02 0xb0 0xb1\n"
      "4 unwind   Illegal\n"
      "4 unwind   Raw Data: 0xb0\n"
      "4 unwind   Illegal\n"
      "4 unwind   Raw Data: 0xb1\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  std::vector<uint8_t> ops{0x16, 0x83, 0x10, 0xa8, 0x01};
  expected = "4 unwind Raw Data: 0x16 0x83 0x10 0xa8 0x01";
  std::string op_string;
  for (uint8_t i = 0; i < 168; i++) {
    ops.push_back(0xa0 + (i % 96));
    op_string += "4 unwind   Illegal\n";
    op_string += android::base::StringPrintf("4 unwind   Raw Data: 0x%02x\n", ops.back());
    expected += android::base::StringPrintf(" 0x%02x", ops.back());
    if (((i + 6) % 10) == 0) {
      expected += "\n4 unwind Raw Data:";
    }
  }
  expected = "4 unwind DW_CFA_val_expression register(2051) 168\n" + expected + "\n";

  this->memory_.SetMemory(0xa00, ops);

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0xa00, 0xaad));

  ASSERT_EQ(expected + op_string, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_gnu_args_size) {
  this->memory_.SetMemory(0x2000, std::vector<uint8_t>{0x2e, 0x04});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x2000, 0x2002));

  std::string expected =
      "4 unwind DW_CFA_GNU_args_size 4\n"
      "4 unwind Raw Data: 0x2e 0x04\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x5000, std::vector<uint8_t>{0x2e, 0xa4, 0x80, 0x04});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x5000, 0x5004));

  expected =
      "4 unwind DW_CFA_GNU_args_size 65572\n"
      "4 unwind Raw Data: 0x2e 0xa4 0x80 0x04\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_gnu_negative_offset_extended) {
  this->memory_.SetMemory(0x500, std::vector<uint8_t>{0x2f, 0x08, 0x10});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x500, 0x503));

  std::string expected =
      "4 unwind DW_CFA_GNU_negative_offset_extended register(8) 16\n"
      "4 unwind Raw Data: 0x2f 0x08 0x10\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());

  ResetLogs();
  this->memory_.SetMemory(0x1500, std::vector<uint8_t>{0x2f, 0x81, 0x02, 0xff, 0x01});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x1500, 0x1505));

  expected =
      "4 unwind DW_CFA_GNU_negative_offset_extended register(257) 255\n"
      "4 unwind Raw Data: 0x2f 0x81 0x02 0xff 0x01\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

TYPED_TEST_P(DwarfCfaLogTest, cfa_register_override) {
  this->memory_.SetMemory(0x300, std::vector<uint8_t>{0x09, 0x02, 0x01, 0x09, 0x02, 0x04});

  ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0, 0x300, 0x306));

  std::string expected =
      "4 unwind DW_CFA_register register(2) register(1)\n"
      "4 unwind Raw Data: 0x09 0x02 0x01\n"
      "4 unwind DW_CFA_register register(2) register(4)\n"
      "4 unwind Raw Data: 0x09 0x02 0x04\n";
  ASSERT_EQ(expected, GetFakeLogPrint());
  ASSERT_EQ("", GetFakeLogBuf());
}

REGISTER_TYPED_TEST_CASE_P(DwarfCfaLogTest, cfa_illegal, cfa_nop, cfa_offset, cfa_offset_extended,
                           cfa_offset_extended_sf, cfa_restore, cfa_restore_extended, cfa_set_loc,
                           cfa_advance_loc, cfa_advance_loc1, cfa_advance_loc2, cfa_advance_loc4,
                           cfa_undefined, cfa_same, cfa_register, cfa_state,
                           cfa_state_cfa_offset_restore, cfa_def_cfa, cfa_def_cfa_sf,
                           cfa_def_cfa_register, cfa_def_cfa_offset, cfa_def_cfa_offset_sf,
                           cfa_def_cfa_expression, cfa_expression, cfa_val_offset,
                           cfa_val_offset_sf, cfa_val_expression, cfa_gnu_args_size,
                           cfa_gnu_negative_offset_extended, cfa_register_override);

typedef ::testing::Types<uint32_t, uint64_t> DwarfCfaLogTestTypes;
INSTANTIATE_TYPED_TEST_CASE_P(, DwarfCfaLogTest, DwarfCfaLogTestTypes);

}  // namespace unwindstack