[lldb] Add a gtest matcher for lldb_private::Value (#167427)

This commit adds a new `ValueMatcher` class that can be used in gtest
matching contexts to match against `lldb_private::Value` objects. We
always match against the values `value_type` and `context_type`. For
HostAddress values we will also match against the expected host buffer
contents. For Scalar, FileAddress, and LoadAddress values we match
against an expected Scalar value.

The matcher is used to improve the quality of the tests in the
`DwarfExpressionTest.cpp` file. Previously, the local `Evaluate`
function would return an `Expected<Scalar>` value which makes it hard to
verify that we actually get a Value of the expected type without adding
custom evaluation code. Now we return an `Expected<Value>` so that we
can match against the full value contents.

The resulting change improves the quality of the existing checks and in
some cases eliminates the need for special code to explicitly check
value types.

I followed the gtest
[guide](https://google.github.io/googletest/gmock_cook_book.html#writing-new-monomorphic-matchers)
for writing a new value matcher.

Author: dmpots

lldb/unittests/Expression/CMakeLists.txt

@@ -10,6 +10,7 @@ add_lldb_unittest(ExpressionTests
   DWARFExpressionTest.cpp
   CppModuleConfigurationTest.cpp
   ExpressionTest.cpp
+  ValueMatcher.cpp
 
   LINK_COMPONENTS
     Support

lldb/unittests/Expression/DWARFExpressionTest.cpp

@@ -5,8 +5,8 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-
 #include "lldb/Expression/DWARFExpression.h"
+#include "ValueMatcher.h"
 #ifdef ARCH_AARCH64
 #include "Plugins/ABI/AArch64/ABISysV_arm64.h"
 #endif
@@ -135,40 +135,18 @@ class MockRegisterContext : public RegisterContext {
 };
 } // namespace
 
-static llvm::Expected<Scalar> Evaluate(llvm::ArrayRef<uint8_t> expr,
-                                       lldb::ModuleSP module_sp = {},
-                                       DWARFUnit *unit = nullptr,
-                                       ExecutionContext *exe_ctx = nullptr,
-                                       RegisterContext *reg_ctx = nullptr) {
+static llvm::Expected<Value> Evaluate(llvm::ArrayRef<uint8_t> expr,
+                                      lldb::ModuleSP module_sp = {},
+                                      DWARFUnit *unit = nullptr,
+                                      ExecutionContext *exe_ctx = nullptr,
+                                      RegisterContext *reg_ctx = nullptr) {
   DataExtractor extractor(expr.data(), expr.size(), lldb::eByteOrderLittle,
                           /*addr_size*/ 4);
 
-  llvm::Expected<Value> result = DWARFExpression::Evaluate(
-      exe_ctx, reg_ctx, module_sp, extractor, unit, lldb::eRegisterKindLLDB,
-      /*initial_value_ptr=*/nullptr,
-      /*object_address_ptr=*/nullptr);
-  if (!result)
-    return result.takeError();
-
-  switch (result->GetValueType()) {
-  case Value::ValueType::Scalar:
-    return result->GetScalar();
-  case Value::ValueType::LoadAddress:
-    return LLDB_INVALID_ADDRESS;
-  case Value::ValueType::HostAddress: {
-    // Convert small buffers to scalars to simplify the tests.
-    DataBufferHeap &buf = result->GetBuffer();
-    if (buf.GetByteSize() <= 8) {
-      uint64_t val = 0;
-      memcpy(&val, buf.GetBytes(), buf.GetByteSize());
-      return Scalar(llvm::APInt(buf.GetByteSize() * 8, val, false));
-    }
-  }
-    [[fallthrough]];
-  default:
-    break;
-  }
-  return llvm::createStringError("unsupported value type");
+  return DWARFExpression::Evaluate(exe_ctx, reg_ctx, module_sp, extractor, unit,
+                                   lldb::eRegisterKindLLDB,
+                                   /*initial_value_ptr=*/nullptr,
+                                   /*object_address_ptr=*/nullptr);
 }
 
 class DWARFExpressionTester : public YAMLModuleTester {
@@ -177,18 +155,11 @@ class DWARFExpressionTester : public YAMLModuleTester {
       : YAMLModuleTester(yaml_data, cu_index) {}
 
   using YAMLModuleTester::YAMLModuleTester;
-  llvm::Expected<Scalar> Eval(llvm::ArrayRef<uint8_t> expr) {
+  llvm::Expected<Value> Eval(llvm::ArrayRef<uint8_t> expr) {
     return ::Evaluate(expr, m_module_sp, m_dwarf_unit);
   }
 };
 
-/// Unfortunately Scalar's operator==() is really picky.
-static Scalar GetScalar(unsigned bits, uint64_t value, bool sign) {
-  Scalar scalar(value);
-  scalar.TruncOrExtendTo(bits, sign);
-  return scalar;
-}
-
 /// This is needed for the tests that use a mock process.
 class DWARFExpressionMockProcessTest : public ::testing::Test {
 public:
@@ -255,48 +226,48 @@ class MockTarget : public Target {
 
 TEST(DWARFExpression, DW_OP_pick) {
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 0}),
-                       llvm::HasValue(0));
+                       ExpectScalar(0));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 1}),
-                       llvm::HasValue(1));
+                       ExpectScalar(1));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 2}),
                        llvm::Failed());
 }
 
 TEST(DWARFExpression, DW_OP_const) {
   // Extend to address size.
-  EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1u, 0x88}), llvm::HasValue(0x88));
+  EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1u, 0x88}), ExpectScalar(0x88));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1s, 0x88}),
-                       llvm::HasValue(0xffffff88));
+                       ExpectScalar(0xffffff88));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2u, 0x47, 0x88}),
-                       llvm::HasValue(0x8847));
+                       ExpectScalar(0x8847));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2s, 0x47, 0x88}),
-                       llvm::HasValue(0xffff8847));
+                       ExpectScalar(0xffff8847));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const4u, 0x44, 0x42, 0x47, 0x88}),
-                       llvm::HasValue(0x88474244));
+                       ExpectScalar(0x88474244));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const4s, 0x44, 0x42, 0x47, 0x88}),
-                       llvm::HasValue(0x88474244));
+                       ExpectScalar(0x88474244));
 
   // Truncate to address size.
   EXPECT_THAT_EXPECTED(
       Evaluate({DW_OP_const8u, 0x00, 0x11, 0x22, 0x33, 0x44, 0x42, 0x47, 0x88}),
-      llvm::HasValue(0x33221100));
+      ExpectScalar(0x33221100));
   EXPECT_THAT_EXPECTED(
       Evaluate({DW_OP_const8s, 0x00, 0x11, 0x22, 0x33, 0x44, 0x42, 0x47, 0x88}),
-      llvm::HasValue(0x33221100));
+      ExpectScalar(0x33221100));
 
   // Don't truncate to address size for compatibility with clang (pr48087).
   EXPECT_THAT_EXPECTED(
       Evaluate({DW_OP_constu, 0x81, 0x82, 0x84, 0x88, 0x90, 0xa0, 0x40}),
-      llvm::HasValue(0x01010101010101));
+      ExpectScalar(0x01010101010101));
   EXPECT_THAT_EXPECTED(
       Evaluate({DW_OP_consts, 0x81, 0x82, 0x84, 0x88, 0x90, 0xa0, 0x40}),
-      llvm::HasValue(0xffff010101010101));
+      ExpectScalar(0xffff010101010101));
 }
 
 TEST(DWARFExpression, DW_OP_skip) {
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const1u, 0x42, DW_OP_skip, 0x02, 0x00,
                                  DW_OP_const1u, 0xff}),
-                       llvm::HasValue(0x42));
+                       ExpectScalar(0x42));
 }
 
 TEST(DWARFExpression, DW_OP_bra) {
@@ -309,7 +280,7 @@ TEST(DWARFExpression, DW_OP_bra) {
         DW_OP_const1u, 0xff,     // push 0xff
       }),
       // clang-format on
-      llvm::HasValue(0x42));
+      ExpectScalar(0x42));
 
   EXPECT_THAT_ERROR(Evaluate({DW_OP_bra, 0x01, 0x00}).takeError(),
                     llvm::Failed());
@@ -414,42 +385,42 @@ TEST(DWARFExpression, DW_OP_convert) {
   EXPECT_THAT_EXPECTED(
       t.Eval({DW_OP_const4u, 0x11, 0x22, 0x33, 0x44, //
               DW_OP_convert, offs_uint32_t, DW_OP_stack_value}),
-      llvm::HasValue(GetScalar(64, 0x44332211, not_signed)));
+      ExpectScalar(64, 0x44332211, not_signed));
 
   // Zero-extend to 64 bits.
   EXPECT_THAT_EXPECTED(
       t.Eval({DW_OP_const4u, 0x11, 0x22, 0x33, 0x44, //
               DW_OP_convert, offs_uint64_t, DW_OP_stack_value}),
-      llvm::HasValue(GetScalar(64, 0x44332211, not_signed)));
+      ExpectScalar(64, 0x44332211, not_signed));
 
   // Sign-extend to 64 bits.
   EXPECT_THAT_EXPECTED(
       t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, //
               DW_OP_convert, offs_sint64_t, DW_OP_stack_value}),
-      llvm::HasValue(GetScalar(64, 0xffffffffffeeddcc, is_signed)));
+      ExpectScalar(64, 0xffffffffffeeddcc, is_signed));
 
   // Sign-extend, then truncate.
   EXPECT_THAT_EXPECTED(
       t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, //
               DW_OP_convert, offs_sint64_t,          //
               DW_OP_convert, offs_uint32_t, DW_OP_stack_value}),
-      llvm::HasValue(GetScalar(32, 0xffeeddcc, not_signed)));
+      ExpectScalar(32, 0xffeeddcc, not_signed));
 
   // Truncate to default unspecified (pointer-sized) type.
   EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 0xcc, 0xdd, 0xee, 0xff, //
                                DW_OP_convert, offs_sint64_t,          //
                                DW_OP_convert, 0x00, DW_OP_stack_value}),
-                       llvm::HasValue(GetScalar(32, 0xffeeddcc, not_signed)));
+                       ExpectScalar(32, 0xffeeddcc, not_signed));
 
   // Truncate to 8 bits.
   EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 'A', 'B', 'C', 'D', DW_OP_convert,
                                offs_uchar, DW_OP_stack_value}),
-                       llvm::HasValue(GetScalar(8, 'A', not_signed)));
+                       ExpectScalar(8, 'A', not_signed));
 
   // Also truncate to 8 bits.
   EXPECT_THAT_EXPECTED(t.Eval({DW_OP_const4s, 'A', 'B', 'C', 'D', DW_OP_convert,
                                offs_schar, DW_OP_stack_value}),
-                       llvm::HasValue(GetScalar(8, 'A', is_signed)));
+                       ExpectScalar(8, 'A', is_signed));
 
   //
   // Errors.
@@ -479,41 +450,29 @@ TEST(DWARFExpression, DW_OP_stack_value) {
 TEST(DWARFExpression, DW_OP_piece) {
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2u, 0x11, 0x22, DW_OP_piece, 2,
                                  DW_OP_const2u, 0x33, 0x44, DW_OP_piece, 2}),
-                       llvm::HasValue(GetScalar(32, 0x44332211, true)));
+                       ExpectHostAddress({0x11, 0x22, 0x33, 0x44}));
   EXPECT_THAT_EXPECTED(
       Evaluate({DW_OP_piece, 1, DW_OP_const1u, 0xff, DW_OP_piece, 1}),
       // Note that the "00" should really be "undef", but we can't
       // represent that yet.
-      llvm::HasValue(GetScalar(16, 0xff00, true)));
-}
-
-TEST(DWARFExpression, DW_OP_piece_host_address) {
-  static const uint8_t expr_data[] = {DW_OP_lit2, DW_OP_stack_value,
-                                      DW_OP_piece, 40};
-  llvm::ArrayRef<uint8_t> expr(expr_data, sizeof(expr_data));
-  DataExtractor extractor(expr.data(), expr.size(), lldb::eByteOrderLittle, 4);
+      ExpectHostAddress({0x00, 0xff}));
 
   // This tests if ap_int is extended to the right width.
   // expect 40*8 = 320 bits size.
-  llvm::Expected<Value> result =
-      DWARFExpression::Evaluate(nullptr, nullptr, nullptr, extractor, nullptr,
-                                lldb::eRegisterKindDWARF, nullptr, nullptr);
-  ASSERT_THAT_EXPECTED(result, llvm::Succeeded());
-  ASSERT_EQ(result->GetValueType(), Value::ValueType::HostAddress);
-  ASSERT_EQ(result->GetBuffer().GetByteSize(), 40ul);
-  const uint8_t *data = result->GetBuffer().GetBytes();
-  ASSERT_EQ(data[0], 2);
-  for (int i = 1; i < 40; i++) {
-    ASSERT_EQ(data[i], 0);
-  }
+  std::vector<uint8_t> expected_host_buffer(40, 0);
+  expected_host_buffer[0] = 2;
+
+  EXPECT_THAT_EXPECTED(
+      Evaluate({{DW_OP_lit2, DW_OP_stack_value, DW_OP_piece, 40}}),
+      ExpectHostAddress(expected_host_buffer));
 }
 
 TEST(DWARFExpression, DW_OP_implicit_value) {
   unsigned char bytes = 4;
 
   EXPECT_THAT_EXPECTED(
       Evaluate({DW_OP_implicit_value, bytes, 0x11, 0x22, 0x33, 0x44}),
-      llvm::HasValue(GetScalar(8 * bytes, 0x44332211, true)));
+      ExpectHostAddress({0x11, 0x22, 0x33, 0x44}));
 }
 
 TEST(DWARFExpression, DW_OP_unknown) {
@@ -548,20 +507,13 @@ TEST_F(DWARFExpressionMockProcessTest, DW_OP_deref) {
   // Implicit location: *0x4.
   EXPECT_THAT_EXPECTED(
       Evaluate({DW_OP_lit4, DW_OP_deref, DW_OP_stack_value}, {}, {}, &exe_ctx),
-      llvm::HasValue(GetScalar(32, 0x07060504, false)));
+      ExpectScalar(32, 0x07060504, false));
   // Memory location: *(*0x4).
-  // Evaluate returns LLDB_INVALID_ADDRESS for all load addresses.
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit4, DW_OP_deref}, {}, {}, &exe_ctx),
-                       llvm::HasValue(Scalar(LLDB_INVALID_ADDRESS)));
+                       ExpectLoadAddress(0x07060504));
   // Memory location: *0x4.
-  // Evaluate returns LLDB_INVALID_ADDRESS for all load addresses.
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit4}, {}, {}, &exe_ctx),
-                       llvm::HasValue(Scalar(4)));
-  // Implicit location: *0x4.
-  // Evaluate returns LLDB_INVALID_ADDRESS for all load addresses.
-  EXPECT_THAT_EXPECTED(
-      Evaluate({DW_OP_lit4, DW_OP_deref, DW_OP_stack_value}, {}, {}, &exe_ctx),
-      llvm::HasValue(GetScalar(32, 0x07060504, false)));
+                       ExpectScalar(Scalar(4)));
 }
 
 TEST_F(DWARFExpressionMockProcessTest, WASM_DW_OP_addr) {
@@ -581,18 +533,9 @@ TEST_F(DWARFExpressionMockProcessTest, WASM_DW_OP_addr) {
 
   ExecutionContext exe_ctx(target_sp, false);
   // DW_OP_addr takes a single operand of address size width:
-  uint8_t expr[] = {DW_OP_addr, 0x40, 0x0, 0x0, 0x0};
-  DataExtractor extractor(expr, sizeof(expr), lldb::eByteOrderLittle,
-                          /*addr_size*/ 4);
-
-  llvm::Expected<Value> result = DWARFExpression::Evaluate(
-      &exe_ctx, /*reg_ctx*/ nullptr, /*module_sp*/ {}, extractor,
-      /*unit*/ nullptr, lldb::eRegisterKindLLDB,
-      /*initial_value_ptr*/ nullptr,
-      /*object_address_ptr*/ nullptr);
-
-  ASSERT_THAT_EXPECTED(result, llvm::Succeeded());
-  ASSERT_EQ(result->GetValueType(), Value::ValueType::LoadAddress);
+  EXPECT_THAT_EXPECTED(
+      Evaluate({DW_OP_addr, 0x40, 0x0, 0x0, 0x0}, {}, {}, &exe_ctx),
+      ExpectLoadAddress(0x40));
 }
 
 TEST_F(DWARFExpressionMockProcessTest, WASM_DW_OP_addr_index) {
@@ -676,15 +619,11 @@ TEST_F(DWARFExpressionMockProcessTest, WASM_DW_OP_addr_index) {
   DWARFExpression expr(extractor);
 
   llvm::Expected<Value> result = evaluate(expr);
-  ASSERT_THAT_EXPECTED(result, llvm::Succeeded());
-  ASSERT_EQ(result->GetValueType(), Value::ValueType::LoadAddress);
-  ASSERT_EQ(result->GetScalar().UInt(), 0x5678u);
+  EXPECT_THAT_EXPECTED(result, ExpectLoadAddress(0x5678u));
 
   ASSERT_TRUE(expr.Update_DW_OP_addr(dwarf_cu, 0xdeadbeef));
   result = evaluate(expr);
-  ASSERT_THAT_EXPECTED(result, llvm::Succeeded());
-  ASSERT_EQ(result->GetValueType(), Value::ValueType::LoadAddress);
-  ASSERT_EQ(result->GetScalar().UInt(), 0xdeadbeefu);
+  EXPECT_THAT_EXPECTED(result, ExpectLoadAddress(0xdeadbeefu));
 }
 
 class CustomSymbolFileDWARF : public SymbolFileDWARF {
@@ -778,11 +717,12 @@ static auto testExpressionVendorExtensions(lldb::ModuleSP module_sp,
                                            RegisterContext *reg_ctx) {
   // Test that expression extensions can be evaluated, for example
   // DW_OP_WASM_location which is not currently handled by DWARFExpression:
-  EXPECT_THAT_EXPECTED(Evaluate({DW_OP_WASM_location, 0x03, // WASM_GLOBAL:0x03
-                                 0x04, 0x00, 0x00,          // index:u32
-                                 0x00, DW_OP_stack_value},
-                                module_sp, &dwarf_unit, nullptr, reg_ctx),
-                       llvm::HasValue(GetScalar(32, 42, false)));
+  EXPECT_THAT_EXPECTED(
+      Evaluate({DW_OP_WASM_location, 0x03, // WASM_GLOBAL:0x03
+                0x04, 0x00, 0x00,          // index:u32
+                0x00, DW_OP_stack_value},
+               module_sp, &dwarf_unit, nullptr, reg_ctx),
+      ExpectScalar(32, 42, false, Value::ContextType::RegisterInfo));
 
   // Test that searches for opcodes work in the presence of extensions:
   uint8_t expr[] = {DW_OP_WASM_location,   0x03, 0x04, 0x00, 0x00, 0x00,
@@ -1148,17 +1088,8 @@ TEST_F(DWARFExpressionMockProcessTest, DW_OP_piece_file_addr) {
 
   uint8_t expr[] = {DW_OP_addr, 0x40, 0x0, 0x0, 0x0, DW_OP_piece, 1,
                     DW_OP_addr, 0x50, 0x0, 0x0, 0x0, DW_OP_piece, 1};
-  DataExtractor extractor(expr, sizeof(expr), lldb::eByteOrderLittle,
-                          /*addr_size=*/4);
-  llvm::Expected<Value> result = DWARFExpression::Evaluate(
-      &exe_ctx, /*reg_ctx=*/nullptr, /*module_sp=*/{}, extractor,
-      /*unit=*/nullptr, lldb::eRegisterKindLLDB,
-      /*initial_value_ptr=*/nullptr,
-      /*object_address_ptr=*/nullptr);
-
-  ASSERT_THAT_EXPECTED(result, llvm::Succeeded());
-  ASSERT_EQ(result->GetValueType(), Value::ValueType::HostAddress);
-  ASSERT_THAT(result->GetBuffer().GetData(), ElementsAre(0x11, 0x22));
+  EXPECT_THAT_EXPECTED(Evaluate(expr, {}, {}, &exe_ctx),
+                       ExpectHostAddress({0x11, 0x22}));
 }
 
 /// A Process whose `ReadMemory` override queries a DenseMap.
@@ -1228,28 +1159,15 @@ TEST_F(DWARFExpressionMockProcessTestWithAArch, DW_op_deref_no_ptr_fixing) {
   process_sp->GetThreadList().AddThread(thread);
 
   auto evaluate_expr = [&](auto &expr_data) {
-    DataExtractor extractor(expr_data, sizeof(expr_data),
-                            lldb::eByteOrderLittle,
-                            /*addr_size*/ 8);
-    DWARFExpression expr(extractor);
-
     ExecutionContext exe_ctx(process_sp);
-    llvm::Expected<Value> result = DWARFExpression::Evaluate(
-        &exe_ctx, reg_ctx_sp.get(), /*module_sp*/ nullptr, extractor,
-        /*unit*/ nullptr, lldb::eRegisterKindLLDB,
-        /*initial_value_ptr=*/nullptr,
-        /*object_address_ptr=*/nullptr);
-    return result;
+    return Evaluate(expr_data, {}, {}, &exe_ctx, reg_ctx_sp.get());
   };
 
   uint8_t expr_reg[] = {DW_OP_breg22, 0};
   llvm::Expected<Value> result_reg = evaluate_expr(expr_reg);
-  ASSERT_THAT_EXPECTED(result_reg, llvm::Succeeded());
-  ASSERT_EQ(result_reg->GetValueType(), Value::ValueType::LoadAddress);
-  ASSERT_EQ(result_reg->GetScalar().ULongLong(), addr);
+  EXPECT_THAT_EXPECTED(result_reg, ExpectLoadAddress(addr));
 
   uint8_t expr_deref[] = {DW_OP_breg22, 0, DW_OP_deref};
   llvm::Expected<Value> result_deref = evaluate_expr(expr_deref);
-  ASSERT_THAT_EXPECTED(result_deref, llvm::Succeeded());
-  ASSERT_EQ(result_deref->GetScalar().ULongLong(), expected_value);
+  EXPECT_THAT_EXPECTED(result_deref, ExpectLoadAddress(expected_value));
 }