[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

 //===-- DWARFExpression.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Expression/DWARFExpression.h"
 
 #include <inttypes.h>
 
 #include <vector>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/dwarf.h"
LLDB_LOG(log,
              "Evaluate_DW_OP_entry_value: call site param evaluation failed");
     return false;
   }
 
   stack.push_back(result);
   return true;
 }
 
+static bool Evaluate_DW_OP_implicit_value(std::vector<Value> &stack,
+                                          ExecutionContext *exe_ctx,
+                                          RegisterContext *reg_ctx,
+                                          const DataExtractor &opcodes,
+                                          lldb::offset_t &opcode_offset,
+                                          Status *error_ptr, Log *log) {
+
+  const uint32_t len = opcodes.GetULEB128(&opcode_offset);
+  const void *data = opcodes.GetData(&opcode_offset, len);
+
+  if (!data) {
+    LLDB_LOG(log, "Evaluate_DW_OP_implicit_value: could not be read data");
+    return false;
+  }
+
+  Value result(data, len);
+  stack.push_back(result);
+  return true;
+}
+
 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);
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: {
+      if (!Evaluate_DW_OP_implicit_value(stack, exe_ctx, reg_ctx, opcodes,
+                                         offset, error_ptr, log)) {
+        LLDB_ERRORF(error_ptr, "Could not evaluate %s.",
+                    DW_OP_value_to_name(op));
+        return false;
+      }
+      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/test/Shell/SymbolFile/DWARF/Inputs/implicit_value.c

+int main() {
+  double d = 3.14;
+  printf("break here");
+  d *= d;
+  return 0;
+}