| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "garnet/bin/zxdb/expr/resolve_ptr_ref.h" |
| #include "garnet/bin/zxdb/common/err.h" |
| #include "garnet/bin/zxdb/common/test_with_loop.h" |
| #include "garnet/bin/zxdb/expr/expr_value.h" |
| #include "garnet/bin/zxdb/symbols/base_type.h" |
| #include "garnet/bin/zxdb/symbols/mock_symbol_data_provider.h" |
| #include "garnet/bin/zxdb/symbols/modified_type.h" |
| #include "garnet/bin/zxdb/symbols/type_test_support.h" |
| #include "gtest/gtest.h" |
| |
| namespace zxdb { |
| |
| namespace { |
| |
| class ResolvePtrRefTest : public TestWithLoop {}; |
| |
| } // namespace |
| |
| TEST_F(ResolvePtrRefTest, NotPointer) { |
| auto provider = fxl::MakeRefCounted<MockSymbolDataProvider>(); |
| |
| auto int32_type = MakeInt32Type(); |
| ExprValue int32_value(int32_type, {0x00, 0x00, 0x00, 0x00}); |
| |
| bool called = false; |
| Err out_err; |
| ExprValue out_value; |
| ResolvePointer(provider, int32_value, [&called, &out_err, &out_value]( |
| const Err& err, ExprValue value) { |
| called = true; |
| out_err = err; |
| out_value = value; |
| }); |
| |
| // This should fail synchronously. |
| EXPECT_TRUE(called); |
| EXPECT_EQ("Attempting to dereference 'int32_t' which is not a pointer.", |
| out_err.msg()); |
| |
| // Pointer with incorrectly sized data. |
| auto int32_ptr_type = fxl::MakeRefCounted<ModifiedType>( |
| Symbol::kTagPointerType, LazySymbol(int32_type)); |
| ExprValue int32_ptr_value(int32_ptr_type, {0x00, 0x00, 0x00, 0x00}); |
| |
| called = false; |
| ResolvePointer( |
| provider, int32_ptr_value, |
| [&called, &out_err, &out_value](const Err& err, ExprValue value) { |
| called = true; |
| out_err = err; |
| out_value = value; |
| }); |
| |
| // This should fail synchronously. |
| EXPECT_TRUE(called); |
| EXPECT_EQ( |
| "The value of type 'int32_t*' is the incorrect size (expecting 8, got " |
| "4). Please file a bug.", |
| out_err.msg()); |
| } |
| |
| TEST_F(ResolvePtrRefTest, InvalidMemory) { |
| auto provider = fxl::MakeRefCounted<MockSymbolDataProvider>(); |
| constexpr uint64_t kAddress = 0x10; |
| |
| auto int32_type = MakeInt32Type(); |
| |
| // This read will return no data. |
| bool called = false; |
| Err out_err; |
| ExprValue out_value; |
| ResolvePointer( |
| provider, kAddress, int32_type, |
| [&called, &out_err, &out_value](const Err& err, ExprValue value) { |
| called = true; |
| out_err = err; |
| out_value = value; |
| debug_ipc::MessageLoop::Current()->QuitNow(); |
| }); |
| |
| EXPECT_FALSE(called); |
| loop().Run(); |
| EXPECT_TRUE(called); |
| EXPECT_EQ("Invalid pointer 0x10", out_err.msg()); |
| |
| // This read will return only 2 bytes (it requires 4). |
| provider->AddMemory(kAddress, {0x00, 0x00}); |
| called = false; |
| out_err = Err(); |
| ResolvePointer( |
| provider, kAddress, int32_type, |
| [&called, &out_err, &out_value](const Err& err, ExprValue value) { |
| called = true; |
| out_err = err; |
| out_value = value; |
| debug_ipc::MessageLoop::Current()->QuitNow(); |
| }); |
| |
| EXPECT_FALSE(called); |
| loop().Run(); |
| EXPECT_TRUE(called); |
| EXPECT_EQ("Invalid pointer 0x10", out_err.msg()); |
| } |
| |
| // Tests EnsureResolveReference when the value is not a reference. |
| TEST_F(ResolvePtrRefTest, NotRef) { |
| auto provider = fxl::MakeRefCounted<MockSymbolDataProvider>(); |
| auto int32_type = MakeInt32Type(); |
| |
| ExprValue value(123); |
| |
| bool called = false; |
| ExprValue out_value; |
| EnsureResolveReference( |
| provider, value, [&called, &out_value](const Err& err, ExprValue result) { |
| EXPECT_FALSE(err.has_error()); |
| called = true; |
| out_value = result; |
| }); |
| |
| // Should have run synchronously. |
| EXPECT_TRUE(called); |
| EXPECT_EQ(value, out_value); |
| } |
| |
| // Tests EnsureResolveReference when the value is a const ref. The const should |
| // get ignored, the ref should be stripped, and the pointed-to value should be |
| // the result. |
| TEST_F(ResolvePtrRefTest, ConstRef) { |
| auto provider = fxl::MakeRefCounted<MockSymbolDataProvider>(); |
| |
| // Add a 32-bit int at a given address. |
| constexpr uint64_t kAddress = 0x300020; |
| std::vector<uint8_t> int_value = {0x04, 0x03, 0x02, 0x01}; |
| provider->AddMemory(kAddress, int_value); |
| |
| // Make "volatile const int32_t&". This tests modifies on both sides of the |
| // reference (volatile on the outside, const on the inside). |
| auto int32_type = MakeInt32Type(); |
| auto const_int32_type = fxl::MakeRefCounted<ModifiedType>( |
| Symbol::kTagConstType, LazySymbol(int32_type)); |
| auto const_int32_ref_type = fxl::MakeRefCounted<ModifiedType>( |
| Symbol::kTagReferenceType, LazySymbol(const_int32_type)); |
| auto volatile_const_int32_ref_type = fxl::MakeRefCounted<ModifiedType>( |
| Symbol::kTagVolatileType, LazySymbol(const_int32_ref_type)); |
| |
| ExprValue value(volatile_const_int32_ref_type, |
| {0x20, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00}); |
| |
| bool called = false; |
| ExprValue out_value; |
| EnsureResolveReference( |
| provider, value, [&called, &out_value](const Err& err, ExprValue result) { |
| EXPECT_FALSE(err.has_error()); |
| called = true; |
| out_value = result; |
| debug_ipc::MessageLoop::Current()->QuitNow(); |
| }); |
| |
| // Should have run asynchronously. |
| EXPECT_FALSE(called); |
| loop().Run(); |
| EXPECT_TRUE(called); |
| |
| // The resolved type should be "const int32_t" and have the input value. |
| EXPECT_EQ(const_int32_type.get(), out_value.type()); |
| EXPECT_EQ(int_value, out_value.data()); |
| |
| // Check the location of the result. |
| EXPECT_EQ(ExprValueSource::Type::kMemory, out_value.source().type()); |
| EXPECT_EQ(kAddress, out_value.source().address()); |
| } |
| |
| } // namespace zxdb |