[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

307

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

2695

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.

2703–2723

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

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

2746

add CU offset like in call2 case.

2754–2774

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

2697–2700

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

2700

include the calculated DIE offset in the error message

2748–2751

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

2751

include the calculated DIE offset in the error message

include/lldb/Expression/DWARFExpression.h

public:
   ///
   /// \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,
+                       const Value *object_address_ptr,
+                       std::vector<Value> &stack,
+                       Value &result,
                        Status *error_ptr);
 
   bool GetExpressionData(DataExtractor &data) const {
     data = m_data;
     return data.GetByteSize() > 0;
   }
 
   bool DumpLocationForAddress(Stream *s, lldb::DescriptionLevel level,

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 (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,
+              m_reg_kind, initial_value_ptr, 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, initial_value_ptr, 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) {
+    std::vector<Value> &stack, Value &result, Status *error_ptr) {
 
   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();
   }

     // 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);
+      const DWARFDIE 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;
+      }
+
+      DWARFAttributes attributes;
+      const size_t num_attrib = ref_die.GetAttributes(attributes);
+      if (num_attrib == 0)
+        break;
+
+      const uint32_t attr_index = attributes.FindAttributeIndex(DW_AT_location);
+      if (attr_index == UINT32_MAX)
+        break;
+
+      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 memberOffset(0);
+      Evaluate(nullptr, nullptr, module_sp, ref_debug_info_data,
+               dwarf_cu, location_offset, location_length,
+               eRegisterKindDWARF, nullptr, nullptr, stack, memberOffset,
+               nullptr);
+    } 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);
+      const DWARFDIE 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;
+      }
+
+      DWARFAttributes attributes;
+      const size_t num_attrib = ref_die.GetAttributes(attributes);
+      if (num_attrib == 0)
+        break;
+
+      const uint32_t attr_index = attributes.FindAttributeIndex(DW_AT_location);
+      if (attr_index == UINT32_MAX)
+        break;
+
+      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 memberOffset(0);
+      Evaluate(nullptr, nullptr, module_sp, ref_debug_info_data,
+               dwarf_cu, location_offset, location_length,
+               eRegisterKindDWARF, nullptr, nullptr, stack, memberOffset,
+               nullptr);
+    } 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);

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

case DW_TAG_APPLE_property: {
             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;
                 if (DWARFExpression::Evaluate(
                         nullptr, // ExecutionContext *
                         nullptr, // RegisterContext *
                         module_sp, debug_info_data, die.GetCU(), block_offset,
                         block_length, eRegisterKindDWARF, &initialValue,
-                        nullptr, memberOffset, nullptr)) {
+                        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;
                 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)) {
+                                              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)) {
+                          nullptr, 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))
+          /*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());
 }