1 files changed, 468 insertions, 0 deletions
diff --git a/externals/breakpad/src/processor/disassembler_objdump_unittest.cc b/externals/breakpad/src/processor/disassembler_objdump_unittest.cc
new file mode 100644
index 0000000000..30a60da5ab
--- /dev/null
+++ b/externals/breakpad/src/processor/disassembler_objdump_unittest.cc
@@ -0,0 +1,468 @@
+// Copyright (c) 2022, Google LLC
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google LLC nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>  // Must come first
+#endif
+
+#include <unistd.h>
+#include <vector>
+
+#include "breakpad_googletest_includes.h"
+
+#include "google_breakpad/common/breakpad_types.h"
+#include "google_breakpad/common/minidump_cpu_amd64.h"
+#include "google_breakpad/common/minidump_cpu_x86.h"
+#include "google_breakpad/processor/dump_context.h"
+#include "google_breakpad/processor/memory_region.h"
+#include "processor/disassembler_objdump.h"
+
+namespace google_breakpad {
+class DisassemblerObjdumpForTest : public DisassemblerObjdump {
+ public:
+  using DisassemblerObjdump::CalculateAddress;
+  using DisassemblerObjdump::DisassembleInstruction;
+  using DisassemblerObjdump::TokenizeInstruction;
+};
+
+class TestMemoryRegion : public MemoryRegion {
+ public:
+  TestMemoryRegion(uint64_t base, std::vector<uint8_t> bytes);
+  ~TestMemoryRegion() override = default;
+
+  uint64_t GetBase() const override;
+  uint32_t GetSize() const override;
+
+  bool GetMemoryAtAddress(uint64_t address, uint8_t* value) const override;
+  bool GetMemoryAtAddress(uint64_t address, uint16_t* value) const override;
+  bool GetMemoryAtAddress(uint64_t address, uint32_t* value) const override;
+  bool GetMemoryAtAddress(uint64_t address, uint64_t* value) const override;
+
+  void Print() const override;
+
+ private:
+  uint64_t base_;
+  std::vector<uint8_t> bytes_;
+};
+
+TestMemoryRegion::TestMemoryRegion(uint64_t address, std::vector<uint8_t> bytes)
+    : base_(address), bytes_(bytes) {}
+
+uint64_t TestMemoryRegion::GetBase() const {
+  return base_;
+}
+
+uint32_t TestMemoryRegion::GetSize() const {
+  return static_cast<uint32_t>(bytes_.size());
+}
+
+bool TestMemoryRegion::GetMemoryAtAddress(uint64_t address,
+                                          uint8_t* value) const {
+  if (address < GetBase() ||
+      address + sizeof(uint8_t) > GetBase() + GetSize()) {
+    return false;
+  }
+
+  memcpy(value, &bytes_[address - GetBase()], sizeof(uint8_t));
+  return true;
+}
+
+// We don't use the following functions, so no need to implement.
+bool TestMemoryRegion::GetMemoryAtAddress(uint64_t address,
+                                          uint16_t* value) const {
+  return false;
+}
+
+bool TestMemoryRegion::GetMemoryAtAddress(uint64_t address,
+                                          uint32_t* value) const {
+  return false;
+}
+
+bool TestMemoryRegion::GetMemoryAtAddress(uint64_t address,
+                                          uint64_t* value) const {
+  return false;
+}
+
+void TestMemoryRegion::Print() const {}
+
+const uint32_t kX86TestDs = 0x01000000;
+const uint32_t kX86TestEs = 0x02000000;
+const uint32_t kX86TestFs = 0x03000000;
+const uint32_t kX86TestGs = 0x04000000;
+const uint32_t kX86TestEax = 0x00010101;
+const uint32_t kX86TestEbx = 0x00020202;
+const uint32_t kX86TestEcx = 0x00030303;
+const uint32_t kX86TestEdx = 0x00040404;
+const uint32_t kX86TestEsi = 0x00050505;
+const uint32_t kX86TestEdi = 0x00060606;
+const uint32_t kX86TestEsp = 0x00070707;
+const uint32_t kX86TestEbp = 0x00080808;
+const uint32_t kX86TestEip = 0x23230000;
+
+const uint64_t kAMD64TestRax = 0x0000010101010101ul;
+const uint64_t kAMD64TestRbx = 0x0000020202020202ul;
+const uint64_t kAMD64TestRcx = 0x0000030303030303ul;
+const uint64_t kAMD64TestRdx = 0x0000040404040404ul;
+const uint64_t kAMD64TestRsi = 0x0000050505050505ul;
+const uint64_t kAMD64TestRdi = 0x0000060606060606ul;
+const uint64_t kAMD64TestRsp = 0x0000070707070707ul;
+const uint64_t kAMD64TestRbp = 0x0000080808080808ul;
+const uint64_t kAMD64TestR8 = 0x0000090909090909ul;
+const uint64_t kAMD64TestR9 = 0x00000a0a0a0a0a0aul;
+const uint64_t kAMD64TestR10 = 0x00000b0b0b0b0b0bul;
+const uint64_t kAMD64TestR11 = 0x00000c0c0c0c0c0cul;
+const uint64_t kAMD64TestR12 = 0x00000d0d0d0d0d0dul;
+const uint64_t kAMD64TestR13 = 0x00000e0e0e0e0e0eul;
+const uint64_t kAMD64TestR14 = 0x00000f0f0f0f0f0ful;
+const uint64_t kAMD64TestR15 = 0x0000001010101010ul;
+const uint64_t kAMD64TestRip = 0x0000000023230000ul;
+
+class TestDumpContext : public DumpContext {
+ public:
+  TestDumpContext(bool x86_64 = false);
+  ~TestDumpContext() override;
+};
+
+TestDumpContext::TestDumpContext(bool x86_64) {
+  if (!x86_64) {
+    MDRawContextX86* raw_context = new MDRawContextX86();
+    memset(raw_context, 0, sizeof(*raw_context));
+
+    raw_context->context_flags = MD_CONTEXT_X86_FULL;
+
+    raw_context->ds = kX86TestDs;
+    raw_context->es = kX86TestEs;
+    raw_context->fs = kX86TestFs;
+    raw_context->gs = kX86TestGs;
+    raw_context->eax = kX86TestEax;
+    raw_context->ebx = kX86TestEbx;
+    raw_context->ecx = kX86TestEcx;
+    raw_context->edx = kX86TestEdx;
+    raw_context->esi = kX86TestEsi;
+    raw_context->edi = kX86TestEdi;
+    raw_context->esp = kX86TestEsp;
+    raw_context->ebp = kX86TestEbp;
+    raw_context->eip = kX86TestEip;
+
+    SetContextFlags(raw_context->context_flags);
+    SetContextX86(raw_context);
+    this->valid_ = true;
+  } else {
+    MDRawContextAMD64* raw_context = new MDRawContextAMD64();
+    memset(raw_context, 0, sizeof(*raw_context));
+
+    raw_context->context_flags = MD_CONTEXT_AMD64_FULL;
+
+    raw_context->rax = kAMD64TestRax;
+    raw_context->rbx = kAMD64TestRbx;
+    raw_context->rcx = kAMD64TestRcx;
+    raw_context->rdx = kAMD64TestRdx;
+    raw_context->rsi = kAMD64TestRsi;
+    raw_context->rdi = kAMD64TestRdi;
+    raw_context->rsp = kAMD64TestRsp;
+    raw_context->rbp = kAMD64TestRbp;
+    raw_context->r8 = kAMD64TestR8;
+    raw_context->r9 = kAMD64TestR9;
+    raw_context->r10 = kAMD64TestR10;
+    raw_context->r11 = kAMD64TestR11;
+    raw_context->r12 = kAMD64TestR12;
+    raw_context->r13 = kAMD64TestR13;
+    raw_context->r14 = kAMD64TestR14;
+    raw_context->r15 = kAMD64TestR15;
+    raw_context->rip = kAMD64TestRip;
+
+    SetContextFlags(raw_context->context_flags);
+    SetContextAMD64(raw_context);
+    this->valid_ = true;
+  }
+}
+
+TestDumpContext::~TestDumpContext() {
+  FreeContext();
+}
+
+TEST(DisassemblerObjdumpTest, DisassembleInstructionX86) {
+  string instruction;
+  ASSERT_FALSE(DisassemblerObjdumpForTest::DisassembleInstruction(
+      MD_CONTEXT_X86, nullptr, 0, instruction));
+  std::vector<uint8_t> pop_eax = {0x58};
+  ASSERT_TRUE(DisassemblerObjdumpForTest::DisassembleInstruction(
+      MD_CONTEXT_X86, pop_eax.data(), pop_eax.size(), instruction));
+  ASSERT_EQ(instruction, "pop    eax");
+}
+
+TEST(DisassemblerObjdumpTest, DisassembleInstructionAMD64) {
+  string instruction;
+  ASSERT_FALSE(DisassemblerObjdumpForTest::DisassembleInstruction(
+      MD_CONTEXT_AMD64, nullptr, 0, instruction));
+  std::vector<uint8_t> pop_rax = {0x58};
+  ASSERT_TRUE(DisassemblerObjdumpForTest::DisassembleInstruction(
+      MD_CONTEXT_AMD64, pop_rax.data(), pop_rax.size(), instruction));
+  ASSERT_EQ(instruction, "pop    rax");
+}
+
+TEST(DisassemblerObjdumpTest, TokenizeInstruction) {
+  string operation, dest, src;
+  ASSERT_TRUE(DisassemblerObjdumpForTest::TokenizeInstruction(
+      "pop eax", operation, dest, src));
+  ASSERT_EQ(operation, "pop");
+  ASSERT_EQ(dest, "eax");
+
+  ASSERT_TRUE(DisassemblerObjdumpForTest::TokenizeInstruction(
+      "mov eax, ebx", operation, dest, src));
+  ASSERT_EQ(operation, "mov");
+  ASSERT_EQ(dest, "eax");
+  ASSERT_EQ(src, "ebx");
+
+  ASSERT_TRUE(DisassemblerObjdumpForTest::TokenizeInstruction(
+      "pop rax", operation, dest, src));
+  ASSERT_EQ(operation, "pop");
+  ASSERT_EQ(dest, "rax");
+
+  ASSERT_TRUE(DisassemblerObjdumpForTest::TokenizeInstruction(
+      "mov rax, rbx", operation, dest, src));
+  ASSERT_EQ(operation, "mov");
+  ASSERT_EQ(dest, "rax");
+  ASSERT_EQ(src, "rbx");
+
+  // Test the three parsing failure paths
+  ASSERT_FALSE(DisassemblerObjdumpForTest::TokenizeInstruction(
+      "mov rax,", operation, dest, src));
+  ASSERT_FALSE(DisassemblerObjdumpForTest::TokenizeInstruction(
+      "mov rax rbx", operation, dest, src));
+  ASSERT_FALSE(DisassemblerObjdumpForTest::TokenizeInstruction(
+      "mov rax, rbx, rcx", operation, dest, src));
+
+  // This is of course a nonsense instruction, but test that we do remove
+  // multiple instruction prefixes and can handle multiple memory operands.
+  ASSERT_TRUE(DisassemblerObjdumpForTest::TokenizeInstruction(
+      "rep lock mov DWORD PTR rax, QWORD PTR rbx", operation, dest, src));
+  ASSERT_EQ(operation, "mov");
+  ASSERT_EQ(dest, "rax");
+  ASSERT_EQ(src, "rbx");
+
+  // Test that we ignore junk following a valid instruction
+  ASSERT_TRUE(DisassemblerObjdumpForTest::TokenizeInstruction(
+      "mov rax, rbx ; junk here", operation, dest, src));
+  ASSERT_EQ(operation, "mov");
+  ASSERT_EQ(dest, "rax");
+  ASSERT_EQ(src, "rbx");
+}
+
+namespace x86 {
+const TestMemoryRegion load_reg(kX86TestEip, {0x8b, 0x06});  // mov eax, [esi];
+
+const TestMemoryRegion load_reg_index(kX86TestEip,
+                                      {0x8b, 0x04,
+                                       0xbe});  // mov eax, [esi+edi*4];
+
+const TestMemoryRegion load_reg_offset(kX86TestEip,
+                                       {0x8b, 0x46,
+                                        0x10});  // mov eax, [esi+0x10];
+
+const TestMemoryRegion load_reg_index_offset(
+    kX86TestEip,
+    {0x8b, 0x44, 0xbe, 0xf0});  // mov eax, [esi+edi*4-0x10];
+
+const TestMemoryRegion rep_stosb(kX86TestEip, {0xf3, 0xaa});  // rep stosb;
+
+const TestMemoryRegion lock_cmpxchg(kX86TestEip,
+                                    {0xf0, 0x0f, 0xb1, 0x46,
+                                     0x10});  // lock cmpxchg [esi + 0x10], eax;
+
+const TestMemoryRegion call_reg_offset(kX86TestEip,
+                                       {0xff, 0x96, 0x99, 0x99, 0x99,
+                                        0x09});  // call [esi+0x9999999];
+}  // namespace x86
+
+TEST(DisassemblerObjdumpTest, X86LoadReg) {
+  TestDumpContext context;
+  DisassemblerObjdump dis(context.GetContextCPU(), &x86::load_reg, kX86TestEip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_FALSE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_TRUE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(src_address, kX86TestEsi);
+}
+
+TEST(DisassemblerObjdumpTest, X86LoadRegIndex) {
+  TestDumpContext context;
+  DisassemblerObjdump dis(context.GetContextCPU(), &x86::load_reg_index,
+                          kX86TestEip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_FALSE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_TRUE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(src_address, kX86TestEsi + (kX86TestEdi * 4));
+}
+
+TEST(DisassemblerObjdumpTest, X86LoadRegOffset) {
+  TestDumpContext context;
+  DisassemblerObjdump dis(context.GetContextCPU(), &x86::load_reg_offset,
+                          kX86TestEip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_FALSE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_TRUE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(src_address, kX86TestEsi + 0x10);
+}
+
+TEST(DisassemblerObjdumpTest, X86LoadRegIndexOffset) {
+  TestDumpContext context;
+  DisassemblerObjdump dis(context.GetContextCPU(), &x86::load_reg_index_offset,
+                          kX86TestEip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_FALSE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_TRUE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(src_address, kX86TestEsi + (kX86TestEdi * 4) - 0x10);
+}
+
+TEST(DisassemblerObjdumpTest, X86RepStosb) {
+  TestDumpContext context;
+  DisassemblerObjdump dis(context.GetContextCPU(), &x86::rep_stosb,
+                          kX86TestEip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_TRUE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_FALSE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(dest_address, kX86TestEs + kX86TestEdi);
+}
+
+TEST(DisassemblerObjdumpTest, X86LockCmpxchg) {
+  TestDumpContext context;
+  DisassemblerObjdump dis(context.GetContextCPU(), &x86::lock_cmpxchg,
+                          kX86TestEip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_TRUE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_FALSE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(dest_address, kX86TestEsi + 0x10);
+}
+
+TEST(DisassemblerObjdumpTest, X86CallRegOffset) {
+  TestDumpContext context;
+  DisassemblerObjdump dis(context.GetContextCPU(), &x86::call_reg_offset,
+                          kX86TestEip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_TRUE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_FALSE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(dest_address, kX86TestEsi + 0x9999999);
+}
+
+namespace amd64 {
+const TestMemoryRegion load_reg(kAMD64TestRip,
+                                {0x48, 0x8b, 0x06});  // mov rax, [rsi];
+
+const TestMemoryRegion load_reg_index(kAMD64TestRip,
+                                      {0x48, 0x8b, 0x04,
+                                       0xbe});  // mov rax, [rsi+rdi*4];
+
+const TestMemoryRegion load_rip_relative(kAMD64TestRip,
+                                         {0x48, 0x8b, 0x05, 0x10, 0x00, 0x00,
+                                          0x00});  // mov rax, [rip+0x10];
+
+const TestMemoryRegion load_reg_index_offset(
+    kAMD64TestRip,
+    {0x48, 0x8b, 0x44, 0xbe, 0xf0});  // mov rax, [rsi+rdi*4-0x10];
+
+const TestMemoryRegion rep_stosb(kAMD64TestRip, {0xf3, 0xaa});  // rep stosb;
+
+const TestMemoryRegion lock_cmpxchg(kAMD64TestRip,
+                                    {0xf0, 0x48, 0x0f, 0xb1, 0x46,
+                                     0x10});  // lock cmpxchg [rsi + 0x10], rax;
+
+const TestMemoryRegion call_reg_offset(kAMD64TestRip,
+                                       {0xff, 0x96, 0x99, 0x99, 0x99,
+                                        0x09});  // call [rsi+0x9999999];
+}  // namespace amd64
+
+TEST(DisassemblerObjdumpTest, AMD64LoadReg) {
+  TestDumpContext context(true);
+  DisassemblerObjdump dis(context.GetContextCPU(), &amd64::load_reg,
+                          kAMD64TestRip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_FALSE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_TRUE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(src_address, kAMD64TestRsi);
+}
+
+TEST(DisassemblerObjdumpTest, AMD64LoadRegIndex) {
+  TestDumpContext context(true);
+  DisassemblerObjdump dis(context.GetContextCPU(), &amd64::load_reg_index,
+                          kAMD64TestRip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_FALSE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_TRUE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(src_address, kAMD64TestRsi + (kAMD64TestRdi * 4));
+}
+
+TEST(DisassemblerObjdumpTest, AMD64LoadRipRelative) {
+  TestDumpContext context(true);
+  DisassemblerObjdump dis(context.GetContextCPU(), &amd64::load_rip_relative,
+                          kAMD64TestRip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_FALSE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_TRUE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(src_address, kAMD64TestRip + 0x10);
+}
+
+TEST(DisassemblerObjdumpTest, AMD64LoadRegIndexOffset) {
+  TestDumpContext context(true);
+  DisassemblerObjdump dis(context.GetContextCPU(),
+                          &amd64::load_reg_index_offset, kAMD64TestRip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_FALSE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_TRUE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(src_address, kAMD64TestRsi + (kAMD64TestRdi * 4) - 0x10);
+}
+
+TEST(DisassemblerObjdumpTest, AMD64RepStosb) {
+  TestDumpContext context(true);
+  DisassemblerObjdump dis(context.GetContextCPU(), &amd64::rep_stosb,
+                          kAMD64TestRip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_TRUE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_FALSE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(dest_address, kAMD64TestRdi);
+}
+
+TEST(DisassemblerObjdumpTest, AMD64LockCmpxchg) {
+  TestDumpContext context(true);
+  DisassemblerObjdump dis(context.GetContextCPU(), &amd64::lock_cmpxchg,
+                          kAMD64TestRip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_TRUE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_FALSE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(dest_address, kAMD64TestRsi + 0x10);
+}
+
+TEST(DisassemblerObjdumpTest, AMD64CallRegOffset) {
+  TestDumpContext context(true);
+  DisassemblerObjdump dis(context.GetContextCPU(), &amd64::call_reg_offset,
+                          kAMD64TestRip);
+  uint64_t src_address = 0, dest_address = 0;
+  ASSERT_TRUE(dis.CalculateDestAddress(context, dest_address));
+  ASSERT_FALSE(dis.CalculateSrcAddress(context, src_address));
+  ASSERT_EQ(dest_address, kAMD64TestRsi + 0x9999999);
+}
+}  // namespace google_breakpad