[lldb] Added support for dwarf expressions DW_OP_call2/DW_OP_call4

[Chirag]

Summary

dwarf expression DW_OP_call2/DW_OP_call4 performs dwarf procedure calls during evaluation of a dwarf expression or location description. The 2-byte unsigned offset for DW_OP_call2 (4-byte unsigned offset for DW_OP_call4) is a die entry in the current compilation unit. These operations transfer control of DWARF expression evaluation to the DW_AT_location attribute of the referenced die entry. If there is no such attribute present then there is no effect. the evaluation stack is shared between caller/callee and callee may add to/remove from the value on stack.

[clayborg]

include/lldb/Expression/DWARFExpression.h

303–304

Do we need "initial_value_ptr" anymore? We should be able to remove it and just use the "stack" argument you added below. Probably best to just turn this value into:

std::vector<Value> &stack

And remove the "std::vector<Value> &stack" below.

source/Expression/DWARFExpression.cpp

2699

die_ref_offset us a CU relative offset. You must add "dwarf_cu->GetOffset()" to this to get the correct absolute DIE offset:

dw_offset_t die_ref_offset = opcodes.GetU16(&offset) + dwarf_cu->GetOffset();

Your example will work for the first compile unit and fail for any subsequent ones since the first CU is at offset zero.

2707–2727

Make these lines into a function of DWARFExpression and call it for call2 and call4:

... DWARFExpression::EvaluateCall(DWARFDie Die, ....)

2731

add CU offset like in call2 case.

2739–2759

call new DWARFExpression::EvaluateCall() function you created as noted in above inlined comment.

[clayborg]

Need to add a test for this as well. And to cover all cases, you will need to test in a multi-compile unit example so we can ensure the relative CU offset of the call2 or call4 works in compile units that aren't the first one.

[Chirag]

Fixed as per comments. passed proper execution/register context. for the time being DW_OP_piece is not allowed in call op. Working on testcase.

[clayborg]

A few nits and waiting for the test case.

source/Expression/DWARFExpression.cpp

2701–2704

Move these lines into EvaluateCall and pass "die_ref_offset" as the argument instead of "ref_die"

2704

include the calculated DIE offset in the error message

2733–2736

Move these lines into EvaluateCall and pass "die_ref_offset" as the argument instead of "ref_die"

2736

include the calculated DIE offset in the error message

include/lldb/Expression/DWARFExpression.h

 #include "lldb/Core/Disassembler.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 #include <functional>
 
 class DWARFUnit;
+class DWARFDIE;
 
 namespace lldb_private {
 
 /// \class DWARFExpression DWARFExpression.h
 /// "lldb/Expression/DWARFExpression.h" Encapsulates a DWARF location
 /// expression and interprets it.
 ///
 /// DWARF location expressions are used in two ways by LLDB.  The first
public:
   ///     The offset of the location expression in the data extractor.
   ///
   /// \param[in] length
   ///     The length in bytes of the location expression.
   ///
   /// \param[in] reg_set
   ///     The call-frame-info style register kind.
   ///
-  /// \param[in] initial_value_ptr
-  ///     A value to put on top of the interpreter stack before evaluating
-  ///     the expression, if the expression is parametrized.  Can be NULL.
+  /// \param[in] stack
+  ///     interpreter stack for evaluation of dwarf expression. It is shared
+  ///     between calls in case of adding/removing entries from stack.
   ///
   /// \param[in] result
   ///     A value into which the result of evaluating the expression is
   ///     to be placed.
   ///
   /// \param[in] error_ptr
   ///     If non-NULL, used to report errors in expression evaluation.
   ///
   /// \return
   ///     True on success; false otherwise.  If error_ptr is non-NULL,
   ///     details of the failure are provided through it.
   static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
                        lldb::ModuleSP opcode_ctx, const DataExtractor &opcodes,
                        DWARFUnit *dwarf_cu, const lldb::offset_t offset,
                        const lldb::offset_t length,
                        const lldb::RegisterKind reg_set,
-                       const Value *initial_value_ptr,
-                       const Value *object_address_ptr, Value &result,
-                       Status *error_ptr);
+                       const Value *object_address_ptr,
+                       std::vector<Value> &stack, Value &result,
+                       Status *error_ptr, bool expression_call = false);
+
+  static bool EvaluateCall(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
+                           lldb::ModuleSP module_sp, DWARFUnit *dwarf_cu,
+                           DWARFDIE *ref_die, const lldb::RegisterKind reg_set,
+                           const Value *object_address_ptr,
+                           std::vector<Value> &stack, Status *error_ptr);
 
   bool GetExpressionData(DataExtractor &data) const {
     data = m_data;
     return data.GetByteSize() > 0;
   }
 
   bool DumpLocationForAddress(Stream *s, lldb::DescriptionLevel level,
                               lldb::addr_t loclist_base_load_addr,

source/Expression/DWARFExpression.cpp

 
 bool DWARFExpression::Evaluate(ExecutionContext *exe_ctx,
                                RegisterContext *reg_ctx,
                                lldb::addr_t loclist_base_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();
+  std::vector<Value> stack;
+  if (initial_value_ptr)
+    stack.push_back(*initial_value_ptr);
 
   if (IsLocationList()) {
     lldb::offset_t offset = 0;
     addr_t pc;
     StackFrame *frame = NULL;
     if (reg_ctx)
       pc = reg_ctx->GetPC();
     else {
if (loclist_base_load_addr != LLDB_INVALID_ADDRESS) {
         lo_pc += curr_loclist_base_load_addr - m_loclist_slide;
         hi_pc += curr_loclist_base_load_addr - m_loclist_slide;
 
         uint16_t length = m_data.GetU16(&offset);
 
         if (length > 0 && lo_pc <= pc && pc < hi_pc) {
           return DWARFExpression::Evaluate(
               exe_ctx, reg_ctx, module_sp, m_data, m_dwarf_cu, offset, length,
-              m_reg_kind, initial_value_ptr, object_address_ptr, result,
-              error_ptr);
+              m_reg_kind, object_address_ptr, stack, result, error_ptr);
         }
         offset += length;
       }
     }
     if (error_ptr)
       error_ptr->SetErrorString("variable not available");
     return false;
   }
 
   // Not a location list, just a single expression.
   return DWARFExpression::Evaluate(
       exe_ctx, reg_ctx, module_sp, m_data, m_dwarf_cu, 0, m_data.GetByteSize(),
-      m_reg_kind, initial_value_ptr, object_address_ptr, result, error_ptr);
+      m_reg_kind, object_address_ptr, stack, result, error_ptr);
 }
 
 bool DWARFExpression::Evaluate(
     ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
     lldb::ModuleSP module_sp, const DataExtractor &opcodes,
     DWARFUnit *dwarf_cu, const lldb::offset_t opcodes_offset,
     const lldb::offset_t opcodes_length, const lldb::RegisterKind reg_kind,
-    const Value *initial_value_ptr, const Value *object_address_ptr,
-    Value &result, Status *error_ptr) {
+    const Value *object_address_ptr, std::vector<Value> &stack, Value &result,
+    Status *error_ptr, bool expression_call) {
 
   if (opcodes_length == 0) {
     if (error_ptr)
       error_ptr->SetErrorString(
           "no location, value may have been optimized out");
     return false;
   }
-  std::vector<Value> stack;
 
   Process *process = NULL;
   StackFrame *frame = NULL;
 
   if (exe_ctx) {
     process = exe_ctx->GetProcessPtr();
     frame = exe_ctx->GetFramePtr();
   }
   if (reg_ctx == NULL && frame)
     reg_ctx = frame->GetRegisterContext().get();
 
-  if (initial_value_ptr)
-    stack.push_back(*initial_value_ptr);
-
   lldb::offset_t offset = opcodes_offset;
   const lldb::offset_t end_offset = opcodes_offset + opcodes_length;
   Value tmp;
   uint32_t reg_num;
 
   /// Insertion point for evaluating multi-piece expression.␓
   uint64_t op_piece_offset = 0;
   Value pieces; // Used for DW_OP_piece

     // the entire register, the placement of the piece within that register is
     // defined by the ABI.
     //
     // Many compilers store a single variable in sets of registers, or store a
     // variable partially in memory and partially in registers. DW_OP_piece
     // provides a way of describing how large a part of a variable a particular
     // DWARF expression refers to.
     case DW_OP_piece: {
+      if (expression_call) {
+        if (error_ptr)
+          error_ptr->SetErrorStringWithFormat(
+              "dwarf expression call with DW_OP_piece not supported.");
+        return false;
+      }
+
       const uint64_t piece_byte_size = opcodes.GetULEB128(&offset);
 
       if (piece_byte_size > 0) {
         Value curr_piece;
 
         if (stack.empty()) {
           // In a multi-piece expression, this means that the current piece is
           // not available. Fill with zeros for now by resizing the data and

     // DW_AT_location attribute of the referenced DIE. If there is no such
     // attribute, then there is no effect. Execution of the DWARF expression of
     // a DW_AT_location attribute may add to and/or remove from values on the
     // stack. Execution returns to the point following the call when the end of
     // the attribute is reached. Values on the stack at the time of the call
     // may be used as parameters by the called expression and values left on
     // the stack by the called expression may be used as return values by prior
     // agreement between the calling and called expressions.
-    case DW_OP_call2:
+    case DW_OP_call2: {
+      dw_offset_t die_ref_offset =
+          opcodes.GetU16(&offset) + dwarf_cu->GetOffset();
+      auto ref_die = dwarf_cu->GetDIE(die_ref_offset);
+      if (!ref_die.IsValid()) {
         if (error_ptr)
-        error_ptr->SetErrorString("Unimplemented opcode DW_OP_call2.");
+          error_ptr->SetErrorString("opcode DW_OP_call2 reference not found");
         return false;
+      }
+      EvaluateCall(exe_ctx, reg_ctx, module_sp, dwarf_cu, &ref_die, reg_kind,
+                   object_address_ptr, stack, error_ptr);
+    } break;
+
     // OPCODE: DW_OP_call4
     // OPERANDS: 1
     //      uint32_t compile unit relative offset of a DIE
     // DESCRIPTION: Performs a subroutine call during evaluation of a DWARF
     // expression. For DW_OP_call4, the operand is a 4-byte unsigned offset of
     // a debugging information entry in  the current compilation unit.
     //
     // Operand interpretation DW_OP_call4 is exactly like that for
     // DW_FORM_ref4.
     //
     // This operation transfers control of DWARF expression evaluation to the
     // DW_AT_location attribute of the referenced DIE. If there is no such
     // attribute, then there is no effect. Execution of the DWARF expression of
     // a DW_AT_location attribute may add to and/or remove from values on the
     // stack. Execution returns to the point following the call when the end of
     // the attribute is reached. Values on the stack at the time of the call
     // may be used as parameters by the called expression and values left on
     // the stack by the called expression may be used as return values by prior
     // agreement between the calling and called expressions.
-    case DW_OP_call4:
+    case DW_OP_call4: {
+      dw_offset_t die_ref_offset =
+          opcodes.GetU32(&offset) + dwarf_cu->GetOffset();
+      auto ref_die = dwarf_cu->GetDIE(die_ref_offset);
+      if (!ref_die.IsValid()) {
         if (error_ptr)
-        error_ptr->SetErrorString("Unimplemented opcode DW_OP_call4.");
+          error_ptr->SetErrorString("opcode DW_OP_call4 reference not found");
         return false;
+      }
+      EvaluateCall(exe_ctx, reg_ctx, module_sp, dwarf_cu, &ref_die, reg_kind,
+                   object_address_ptr, stack, error_ptr);
+    } break;
 
     // OPCODE: DW_OP_stack_value
     // OPERANDS: None
     // DESCRIPTION: Specifies that the object does not exist in memory but
     // rather is a constant value.  The value from the top of the stack is the
     // value to be used.  This is the actual object value and not the location.
     case DW_OP_stack_value:
       stack.back().SetValueType(Value::eValueTypeScalar);
       break;
 
     // OPCODE: DW_OP_call_frame_cfa
     // OPERANDS: None
     // DESCRIPTION: Specifies a DWARF expression that pushes the value of
     // the canonical frame address consistent with the call frame information
     // located in .debug_frame (or in the FDEs of the eh_frame section).
     case DW_OP_call_frame_cfa:
       if (frame) {
         // Note that we don't have to parse FDEs because this DWARF expression
         // is commonly evaluated with a valid stack frame.
         StackID id = frame->GetStackID();
         addr_t cfa = id.GetCallFrameAddress();
         if (cfa != LLDB_INVALID_ADDRESS) {
           stack.push_back(Scalar(cfa));
           stack.back().SetValueType(Value::eValueTypeLoadAddress);
         } else if (error_ptr)
           error_ptr->SetErrorString("Stack frame does not include a canonical "
if (log && log->GetVerbose()) {
         log->Printf("  %s", new_value.GetData());
       }
     }
     result = stack.back();
   }
   return true; // Return true on success
 }
 
+bool DWARFExpression::EvaluateCall(ExecutionContext *exe_ctx,
+                                   RegisterContext *reg_ctx,
+                                   ModuleSP module_sp,
+                                   DWARFUnit *dwarf_cu,
+                                   DWARFDIE *ref_die,
+                                   const RegisterKind reg_kind,
+                                   const Value *object_address_ptr,
+                                   std::vector<Value> &stack,
+                                   Status *error_ptr) {
+  if (!ref_die)
+    return false;
+
+  DWARFAttributes attributes;
+  const size_t num_attrib = ref_die->GetAttributes(attributes);
+  if (num_attrib == 0)
+    return false;
+
+  const uint32_t attr_index = attributes.FindAttributeIndex(DW_AT_location);
+  if (attr_index == UINT32_MAX)
+    return false;
+
+  DWARFFormValue form_value;
+  attributes.ExtractFormValueAtIndex(attr_index, form_value);
+
+  const DWARFDataExtractor &ref_debug_info_data = ref_die->GetData();
+  uint32_t location_offset =
+      form_value.BlockData() - ref_debug_info_data.GetDataStart();
+  uint32_t location_length = form_value.Unsigned();
+  Value result(0);
+  return Evaluate(exe_ctx, reg_ctx, module_sp, ref_debug_info_data, dwarf_cu,
+                  location_offset, location_length, reg_kind,
+                  object_address_ptr, stack, result, error_ptr, true);
+}
+
 size_t DWARFExpression::LocationListSize(const DWARFUnit *dwarf_cu,
                                          const DataExtractor &debug_loc_data,
                                          lldb::offset_t offset) {
   const lldb::offset_t debug_loc_offset = offset;
   while (debug_loc_data.ValidOffset(offset)) {
     lldb::addr_t start_addr = LLDB_INVALID_ADDRESS;
     lldb::addr_t end_addr = LLDB_INVALID_ADDRESS;
     if (!AddressRangeForLocationListEntry(dwarf_cu, debug_loc_data, &offset,

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

case DW_TAG_APPLE_property: {
             case DW_AT_byte_size:
               byte_size = form_value.Unsigned();
               break;
             case DW_AT_data_bit_offset:
               data_bit_offset = form_value.Unsigned();
               break;
             case DW_AT_data_member_location:
               if (form_value.BlockData()) {
-                Value initialValue(0);
                 Value memberOffset(0);
                 const DWARFDataExtractor &debug_info_data = die.GetData();
                 uint32_t block_length = form_value.Unsigned();
                 uint32_t block_offset =
                     form_value.BlockData() - debug_info_data.GetDataStart();
+                std::vector<Value> stack;
+                stack.push_back(Value(0));
+
                 if (DWARFExpression::Evaluate(
                         nullptr, // ExecutionContext *
                         nullptr, // RegisterContext *
                         module_sp, debug_info_data, die.GetCU(), block_offset,
-                        block_length, eRegisterKindDWARF, &initialValue,
-                        nullptr, memberOffset, nullptr)) {
+                        block_length, eRegisterKindDWARF, nullptr, stack,
+                        memberOffset, nullptr)) {
                   member_byte_offset = memberOffset.ResolveValue(NULL).UInt();
                 }
               } else {
                 // With DWARF 3 and later, if the value is an integer constant,
                 // this form value is the offset in bytes from the beginning of
                 // the containing entity.
                 member_byte_offset = form_value.Unsigned();
               }
case DW_TAG_inheritance: {
             case DW_AT_type:
               encoding_form = form_value;
               break;
             case DW_AT_data_member_location:
               if (form_value.BlockData()) {
                 Value initialValue(0);
                 Value memberOffset(0);
                 const DWARFDataExtractor &debug_info_data = die.GetData();
+                std::vector<Value> stack;
+                stack.push_back(Value(0));
+
                 uint32_t block_length = form_value.Unsigned();
                 uint32_t block_offset =
                     form_value.BlockData() - debug_info_data.GetDataStart();
                 if (DWARFExpression::Evaluate(nullptr, nullptr, module_sp,
                                               debug_info_data, die.GetCU(),
                                               block_offset, block_length,
-                                              eRegisterKindDWARF, &initialValue,
-                                              nullptr, memberOffset, nullptr)) {
+                                              eRegisterKindDWARF, nullptr,
+                                              stack, memberOffset, nullptr)) {
                   member_byte_offset = memberOffset.ResolveValue(NULL).UInt();
                 }
               } else {
                 // With DWARF 3 and later, if the value is an integer constant,
                 // this form value is the offset in bytes from the beginning of
                 // the containing entity.
                 member_byte_offset = form_value.Unsigned();
               }

source/Target/RegisterContext.cpp

RegisterContext::UpdateDynamicRegisterSize(const lldb_private::ArchSpec &arch,
   DataExtractor dwarf_data(dwarf_opcode_ptr, dwarf_opcode_len,
                            arch.GetByteOrder(), addr_size);
   ModuleSP opcode_ctx;
   DWARFExpression dwarf_expr(opcode_ctx, dwarf_data, nullptr, 0,
                              dwarf_opcode_len);
   Value result;
   Status error;
   const lldb::offset_t offset = 0;
+  std::vector<Value> stack;
   if (dwarf_expr.Evaluate(&exe_ctx, this, opcode_ctx, dwarf_data, nullptr,
                           offset, dwarf_opcode_len, eRegisterKindDWARF, nullptr,
-                          nullptr, result, &error)) {
+                          stack, result, &error)) {
     expr_result = result.GetScalar().SInt(-1);
     switch (expr_result) {
     case 0:
       return 4;
     case 1:
       return 8;
     default:
       return reg_info->byte_size;

unittests/Expression/DWARFExpressionTest.cpp

 using namespace lldb_private;
 
 static llvm::Expected<Scalar> Evaluate(llvm::ArrayRef<uint8_t> expr) {
   DataExtractor extractor(expr.data(), expr.size(), lldb::eByteOrderLittle,
                           /*addr_size*/ 4);
 
   Value result;
   Status status;
+  std::vector<Value> stack;
   if (!DWARFExpression::Evaluate(
           /*exe_ctx*/ nullptr, /*reg_ctx*/ nullptr, /*opcode_ctx*/ nullptr,
           extractor, /*dwarf_cu*/ nullptr, /*offset*/ 0, expr.size(),
-          lldb::eRegisterKindLLDB, /*initial_value_ptr*/ nullptr,
-          /*object_address_ptr*/ nullptr, result, &status))
+          lldb::eRegisterKindLLDB, /*object_address_ptr*/ nullptr, stack,
+          result, &status))
     return status.ToError();
 
   return result.GetScalar();
 }
 
 TEST(DWARFExpression, DW_OP_pick) {
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 0}),
                        llvm::HasValue(0));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 1}),
                        llvm::HasValue(1));
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit1, DW_OP_lit0, DW_OP_pick, 2}),
                        llvm::Failed());
 }