[lldb/DWARF] Add support for DW_OP_implicit_value

[mib]

Summary

This patch completes https://reviews.llvm.org/D83560. Now that the
compiler can emit DW_OP_implicit_value into DWARF expressions, lldb
needed to learn reading these opcodes for variable inspection and
expression evaluation.

This implicit location descriptor specifies an immediate value with two
operands: the length (ULEB128) followed by a block representing the value
in the target memory representation.

rdar://67406091

Signed-off-by: Med Ismail Bennani <[e-mail]>

[mib]

Add test.

[labath]

The code looks pretty straight-forward, but I believe the test should be asm-based with hardcoded dwarf (if you're feeling adventurous, you can also try yaml). My reasons for that are:

• it makes it guarantees (and makes it explicit) the input that is being tested
• the test can run on any platform (if done right -- no launching of processes)
• it enables us to test the error scenario where we fail to read the DW_OP_implicit_value data.

I think the simplest way to produce such a test would be to take DW_TAG_variable-DW_AT_const_value.s and exchange DW_AT_const_value for DW_AT_location/DW_FORM_exprloc

lldb/source/Expression/DWARFExpression.cpp

856–867

I'm not sure this function is really complex enough to justify its existence. The actual code is pretty short and most of it is just argument lists and logging. I don't think the logging is very useful as the caller logs already, and the argument lists would go away if this were inlined.

[JDevlieghere]

+1 on everything Pavel said.

lldb/source/Expression/DWARFExpression.cpp

856–867

Agreed, plus half of the arguments are unused.

[aprantl]

Perhaps the test fits in here https://github.com/llvm/llvm-project/blob/master/lldb/unittests/Expression/DWARFExpressionTest.cpp ?

[labath]

In D89842#2345947, @aprantl wrote:

Perhaps the test fits in here https://github.com/llvm/llvm-project/blob/master/lldb/unittests/Expression/DWARFExpressionTest.cpp ?

Yes, that's even better. :)

[mib]

Change shell test for unit test.

[JDevlieghere]

LGTM

lldb/source/Expression/DWARFExpression.cpp

 
 bool DWARFExpression::Evaluate(ExecutionContextScope *exe_scope,
                                lldb::addr_t loclist_base_load_addr,
                                const Value *initial_value_ptr,
                                const Value *object_address_ptr, Value &result,
                                Status *error_ptr) const {
   ExecutionContext exe_ctx(exe_scope);
   return Evaluate(&exe_ctx, nullptr, loclist_base_load_addr, initial_value_ptr,
                   object_address_ptr, result, error_ptr);
 }
 
 bool DWARFExpression::Evaluate(ExecutionContext *exe_ctx,
                                RegisterContext *reg_ctx,
                                lldb::addr_t func_load_addr,
                                const Value *initial_value_ptr,
                                const Value *object_address_ptr, Value &result,
                                Status *error_ptr) const {
   ModuleSP module_sp = m_module_wp.lock();
 
   if (IsLocationList()) {
     addr_t pc;
     StackFrame *frame = nullptr;
     if (reg_ctx)
       pc = reg_ctx->GetPC();
     else {
       frame = exe_ctx->GetFramePtr();
       if (!frame)
         return false;
case DW_OP_bit_piece: // 0x9d ULEB128 bit size, ULEB128 bit offset (DWARF3);
                 ", bit_offset = %" PRIu64 ") from a vector value.",
                 piece_bit_size, piece_bit_offset);
           }
           return false;
         }
       }
       break;
 
+    // OPCODE: DW_OP_implicit_value
+    // OPERANDS: 2
+    //      ULEB128  size of the value block in bytes
+    //      uint8_t* block bytes encoding value in target's memory
+    //      representation
+    // DESCRIPTION: Value is immediately stored in block in the debug info with
+    // the memory representation of the target.
+    case DW_OP_implicit_value: {
+      const uint32_t len = opcodes.GetULEB128(&offset);
+      const void *data = opcodes.GetData(&offset, len);
+
+      if (!data) {
+        LLDB_LOG(log, "Evaluate_DW_OP_implicit_value: could not be read data");
+        LLDB_ERRORF(error_ptr, "Could not evaluate %s.",
+                    DW_OP_value_to_name(op));
+        return false;
+      }
+
+      Value result(data, len);
+      stack.push_back(result);
+      break;
+    }
+
     // OPCODE: DW_OP_push_object_address
     // OPERANDS: none
     // DESCRIPTION: Pushes the address of the object currently being
     // evaluated as part of evaluation of a user presented expression. This
     // object may correspond to an independent variable described by its own
     // DIE or it may be a component of an array, structure, or class whose
     // address has been dynamically determined by an earlier step during user
     // expression evaluation.

lldb/unittests/Expression/DWARFExpressionTest.cpp

EXPECT_THAT_EXPECTED(Evaluate({DW_OP_const2u, 0x11, 0x22, DW_OP_piece, 2,
                        llvm::HasValue(GetScalar(32, 0x44332211, true)));
   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_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)));
+}
+
 TEST(DWARFExpression, DW_OP_unknown) {
   EXPECT_THAT_EXPECTED(
       Evaluate({0xff}),
       llvm::FailedWithMessage(
           "Unhandled opcode DW_OP_unknown_ff in DWARFExpression"));
 }