Add support for DW_OP_push_object_address in dwarf expressions

[tberghammer]

Summary

Add support for DW_OP_push_object_address in dwarf expressions

Additionally fix the type of some dwarf expression where we had a confusion between scalar and load address types after a dereference.

[clayborg]

Looks good.

[ovyalov]

LGTM

lldb/trunk/include/lldb/Expression/DWARFExpression.h

//
     /// member variables to populate many operands
     //------------------------------------------------------------------
     bool
     Evaluate (ExecutionContextScope *exe_scope,
               ClangExpressionVariableList *expr_locals,
               ClangExpressionDeclMap *decl_map,
               lldb::addr_t loclist_base_load_addr,
               const Value* initial_value_ptr,
+              const Value* object_address_ptr,
               Value& result,
               Error *error_ptr) const;
 
     //------------------------------------------------------------------
     /// Wrapper for the static evaluate function that uses member 
     /// variables to populate many operands
     //------------------------------------------------------------------
     bool
     Evaluate (ExecutionContext *exe_ctx,
               ClangExpressionVariableList *expr_locals,
               ClangExpressionDeclMap *decl_map,
               RegisterContext *reg_ctx,
               lldb::addr_t loclist_base_load_addr,
               const Value* initial_value_ptr,
+              const Value* object_address_ptr,
               Value& result,
               Error *error_ptr) const;
 
     //------------------------------------------------------------------
     /// Evaluate a DWARF location expression in a particular context
     ///
     /// @param[in] exe_ctx
     ///     The execution context in which to evaluate the location
Evaluate (ExecutionContext *exe_ctx,
               RegisterContext *reg_ctx,
               lldb::ModuleSP opcode_ctx,
               const DataExtractor& opcodes,
               DWARFCompileUnit* 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,
               Error *error_ptr);
 
     //------------------------------------------------------------------
     /// Loads a ClangExpressionVariableList into the object
     ///
     /// @param[in] locals
     ///     If non-NULL, the list of locals used by this expression.

lldb/trunk/source/Core/ValueObjectVariable.cpp

else
         if (expr.IsLocationList())
         {
             SymbolContext sc;
             variable->CalculateSymbolContext (&sc);
             if (sc.function)
                 loclist_base_load_addr = sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (target);
         }
         Value old_value(m_value);
-        if (expr.Evaluate (&exe_ctx, NULL, NULL, NULL, loclist_base_load_addr, NULL, m_value, &m_error))
+        if (expr.Evaluate (&exe_ctx,
+                           nullptr,
+                           nullptr,
+                           nullptr,
+                           loclist_base_load_addr,
+                           nullptr,
+                           nullptr,
+                           m_value,
+                           &m_error))
         {
             m_resolved_value = m_value;
             m_value.SetContext(Value::eContextTypeVariable, variable);
             
             CompilerType compiler_type = GetCompilerType();
             if (compiler_type.IsValid())
                 m_value.SetCompilerType(compiler_type);
 

lldb/trunk/source/Expression/DWARFExpression.cpp

 bool
 DWARFExpression::Evaluate
 (
     ExecutionContextScope *exe_scope,
     ClangExpressionVariableList *expr_locals,
     ClangExpressionDeclMap *decl_map,
     lldb::addr_t loclist_base_load_addr,
     const Value* initial_value_ptr,
+    const Value* object_address_ptr,
     Value& result,
     Error *error_ptr
 ) const
 {
     ExecutionContext exe_ctx (exe_scope);
-    return Evaluate(&exe_ctx, expr_locals, decl_map, NULL, loclist_base_load_addr, initial_value_ptr, result, error_ptr);
+    return Evaluate(&exe_ctx,
+                    expr_locals,
+                    decl_map,
+                    nullptr,
+                    loclist_base_load_addr,
+                    initial_value_ptr,
+                    object_address_ptr,
+                    result,
+                    error_ptr);
 }
 
 bool
 DWARFExpression::Evaluate
 (
     ExecutionContext *exe_ctx,
     ClangExpressionVariableList *expr_locals,
     ClangExpressionDeclMap *decl_map,
     RegisterContext *reg_ctx,
     lldb::addr_t loclist_base_load_addr,
     const Value* initial_value_ptr,
+    const Value* object_address_ptr,
     Value& result,
     Error *error_ptr
 ) const
 {
     ModuleSP module_sp = m_module_wp.lock();
 
     if (IsLocationList())
     {
if (IsLocationList())
                                                       reg_ctx,
                                                       module_sp,
                                                       m_data,
                                                       m_dwarf_cu,
                                                       offset,
                                                       length,
                                                       m_reg_kind,
                                                       initial_value_ptr,
+                                                      object_address_ptr,
                                                       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,
                                       expr_locals,
                                       decl_map,
                                       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);
 }
 
 
 
 bool
 DWARFExpression::Evaluate
 (
     ExecutionContext *exe_ctx,
     ClangExpressionVariableList *expr_locals,
     ClangExpressionDeclMap *decl_map,
     RegisterContext *reg_ctx,
     lldb::ModuleSP module_sp,
     const DataExtractor& opcodes,
     DWARFCompileUnit* 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,
     Error *error_ptr
 )
 {
     
     if (opcodes_length == 0)
     {
         if (error_ptr)
//          break;
                 switch (value_type)
                 {
                 case Value::eValueTypeHostAddress:
                     {
                         void *src = (void *)stack.back().GetScalar().ULongLong();
                         intptr_t ptr;
                         ::memcpy (&ptr, src, sizeof(void *));
                         stack.back().GetScalar() = ptr;
+                        stack.back().SetValueType(Value::eValueTypeScalar);
                         stack.back().ClearContext();
                     }
                     break;
                 case Value::eValueTypeLoadAddress:
                     if (exe_ctx)
                     {
                         if (process)
                         {
                             lldb::addr_t pointer_addr = stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
                             Error error;
                             lldb::addr_t pointer_value = process->ReadPointerFromMemory(pointer_addr, error);
                             if (pointer_value != LLDB_INVALID_ADDRESS)
                             {
                                 stack.back().GetScalar() = pointer_value;
+                                stack.back().SetValueType(Value::eValueTypeScalar);
                                 stack.back().ClearContext();
                             }
                             else
                             {
                                 if (error_ptr)
                                     error_ptr->SetErrorStringWithFormat ("Failed to dereference pointer from 0x%" PRIx64 " for DW_OP_deref: %s\n",
                                                                          pointer_addr,
                                                                          error.AsCString());
//          break;
                             // the casts are added to work around the case where intptr_t is a 32 bit quantity;
                             // presumably we won't hit the 5..7 cases if (void*) is 32-bits in this program.
                             case 5: ptr = (intptr_t) ptr & 0xffffffffffULL; break;
                             case 6: ptr = (intptr_t) ptr & 0xffffffffffffULL; break;
                             case 7: ptr = (intptr_t) ptr & 0xffffffffffffffULL; break;
                             default: break;
                         }
                         stack.back().GetScalar() = ptr;
+                        stack.back().SetValueType(Value::eValueTypeScalar);
                         stack.back().ClearContext();
                     }
                     break;
                 case Value::eValueTypeLoadAddress:
                     if (exe_ctx)
                     {
                         if (process)
                         {
                             lldb::addr_t pointer_addr = stack.back().GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
                             uint8_t addr_bytes[sizeof(lldb::addr_t)];
                             Error error;
                             if (process->ReadMemory(pointer_addr, &addr_bytes, size, error) == size)
                             {
                                 DataExtractor addr_data(addr_bytes, sizeof(addr_bytes), process->GetByteOrder(), size);
                                 lldb::offset_t addr_data_offset = 0;
                                 switch (size)
                                 {
                                     case 1: stack.back().GetScalar() = addr_data.GetU8(&addr_data_offset); break;
                                     case 2: stack.back().GetScalar() = addr_data.GetU16(&addr_data_offset); break;
                                     case 4: stack.back().GetScalar() = addr_data.GetU32(&addr_data_offset); break;
                                     case 8: stack.back().GetScalar() = addr_data.GetU64(&addr_data_offset); break;
                                     default: stack.back().GetScalar() = addr_data.GetPointer(&addr_data_offset);
                                 }
+                                stack.back().SetValueType(Value::eValueTypeScalar);
                                 stack.back().ClearContext();
                             }
                             else
                             {
                                 if (error_ptr)
                                     error_ptr->SetErrorStringWithFormat ("Failed to dereference pointer from 0x%" PRIx64 " for DW_OP_deref: %s\n",
                                                                          pointer_addr,
                                                                          error.AsCString());

         // 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.
         //----------------------------------------------------------------------
         case DW_OP_push_object_address:
+            if (object_address_ptr)
+                stack.push_back(*object_address_ptr);
+            else
+            {
                 if (error_ptr)
-                error_ptr->SetErrorString ("Unimplemented opcode DW_OP_push_object_address.");
+                    error_ptr->SetErrorString ("DW_OP_push_object_address used without specifying an object address");
                 return false;
+            }
+            break;
 
         //----------------------------------------------------------------------
         // OPCODE: DW_OP_call2
         // OPERANDS:
         //      uint16_t compile unit relative offset of a DIE
         // DESCRIPTION: Performs subroutine calls during evaluation
         // of a DWARF expression. The operand is the 2-byte unsigned offset
         // of a debugging information entry in the current compilation unit.

lldb/trunk/source/Plugins/Process/Utility/RegisterContextLLDB.cpp

if (unwindplan_regloc.IsDWARFExpression() || unwindplan_regloc.IsAtDWARFExpression())
         DWARFExpression dwarfexpr (opcode_ctx,
                                    dwarfdata,
                                    nullptr,
                                    0,
                                    unwindplan_regloc.GetDWARFExpressionLength());
         dwarfexpr.SetRegisterKind (unwindplan_registerkind);
         Value result;
         Error error;
-        if (dwarfexpr.Evaluate (&exe_ctx, NULL, NULL, this, 0, NULL, result, &error))
+        if (dwarfexpr.Evaluate (&exe_ctx, nullptr, nullptr, this, 0, nullptr, nullptr, result, &error))
         {
             addr_t val;
             val = result.GetScalar().ULongLong();
             if (unwindplan_regloc.IsDWARFExpression())
              {
                 regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
                 regloc.location.inferred_value = val;
                 m_registers[regnum.GetAsKind (eRegisterKindLLDB)] = regloc;
case UnwindPlan::Row::CFAValue::isDWARFExpression:
             DWARFExpression dwarfexpr (opcode_ctx,
                                        dwarfdata,
                                        nullptr,
                                        0,
                                        row->GetCFAValue().GetDWARFExpressionLength());
             dwarfexpr.SetRegisterKind (row_register_kind);
             Value result;
             Error error;
-            if (dwarfexpr.Evaluate (&exe_ctx, NULL, NULL, this, 0, NULL, result, &error))
+            if (dwarfexpr.Evaluate (&exe_ctx, nullptr, nullptr, this, 0, nullptr, nullptr, result, &error))
             {
                 cfa_value = result.GetScalar().ULongLong();
 
                 UnwindLogMsg ("CFA value set by DWARF expression is 0x%" PRIx64, cfa_value);
                 return true;
             }
             UnwindLogMsg ("Failed to set CFA value via DWARF expression: %s", error.AsCString());
             break;

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
                                 case DW_AT_data_member_location:
                                     if (form_value.BlockData())
                                     {
                                         Value initialValue(0);
                                         Value memberOffset(0);
                                         const DWARFDataExtractor& debug_info_data = die.GetDWARF()->get_debug_info_data();
                                         uint32_t block_length = form_value.Unsigned();
                                         uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
-                                        if (DWARFExpression::Evaluate(NULL, // ExecutionContext *
-                                                                      NULL, // ClangExpressionVariableList *
-                                                                      NULL, // ClangExpressionDeclMap *
-                                                                      NULL, // RegisterContext *
+                                        if (DWARFExpression::Evaluate(nullptr, // ExecutionContext *
+                                                                      nullptr, // ClangExpressionVariableList *
+                                                                      nullptr, // ClangExpressionDeclMap *
+                                                                      nullptr, // RegisterContext *
                                                                       module_sp,
                                                                       debug_info_data,
                                                                       die.GetCU(),
                                                                       block_offset,
                                                                       block_length,
                                                                       eRegisterKindDWARF,
                                                                       &initialValue,
+                                                                      nullptr,
                                                                       memberOffset,
-                                                                      NULL))
+                                                                      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
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
                                 case DW_AT_data_member_location:
                                     if (form_value.BlockData())
                                     {
                                         Value initialValue(0);
                                         Value memberOffset(0);
                                         const DWARFDataExtractor& debug_info_data = die.GetDWARF()->get_debug_info_data();
                                         uint32_t block_length = form_value.Unsigned();
                                         uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
-                                        if (DWARFExpression::Evaluate (NULL,
-                                                                       NULL,
-                                                                       NULL,
-                                                                       NULL,
+                                        if (DWARFExpression::Evaluate (nullptr,
+                                                                       nullptr,
+                                                                       nullptr,
+                                                                       nullptr,
                                                                        module_sp,
                                                                        debug_info_data,
                                                                        die.GetCU(),
                                                                        block_offset,
                                                                        block_length,
                                                                        eRegisterKindDWARF,
                                                                        &initialValue,
+                                                                       nullptr,
                                                                        memberOffset,
-                                                                       NULL))
+                                                                       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

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp

for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
                                         uint32_t block_length = form_value.Unsigned();
                                         uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
                                         if (DWARFExpression::Evaluate(NULL, // ExecutionContext *
                                                                       NULL, // ClangExpressionVariableList *
                                                                       NULL, // ClangExpressionDeclMap *
                                                                       NULL, // RegisterContext *
                                                                       module_sp, debug_info_data, die.GetCU(),
                                                                       block_offset, block_length, eRegisterKindDWARF,
-                                                                      &initialValue, memberOffset, NULL))
+                                                                      &initialValue, NULL, memberOffset, NULL))
                                         {
                                             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

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

SymbolFileDWARF::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files)
     DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
     if (dwarf_cu)
     {
         const DWARFDIE cu_die = dwarf_cu->GetCompileUnitDIEOnly();
 
         if (cu_die)
         {
             const char * cu_comp_dir = resolveCompDir(cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr));
-
             const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list, DW_INVALID_OFFSET);
             if (stmt_list != DW_INVALID_OFFSET)
             {
                 // All file indexes in DWARF are one based and a file of index zero is
                 // supposed to be the compile unit itself.
                 support_files.Append (*sc.comp_unit);
                 return DWARFDebugLine::ParseSupportFiles(sc.comp_unit->GetModule(),
                                                          get_debug_line_data(),
if (!m_global_aranges_ap)
                         for (size_t g = 0; g < num_globals; ++g)
                         {
                             VariableSP var_sp = globals_sp->GetVariableAtIndex(g);
                             if (var_sp && !var_sp->GetLocationIsConstantValueData())
                             {
                                 const DWARFExpression &location = var_sp->LocationExpression();
                                 Value location_result;
                                 Error error;
-                                if (location.Evaluate(NULL, NULL, NULL, LLDB_INVALID_ADDRESS, NULL, location_result, &error))
+                                if (location.Evaluate(nullptr, nullptr, nullptr, LLDB_INVALID_ADDRESS, nullptr, nullptr, location_result, &error))
                                 {
                                     if (location_result.GetValueType() == Value::eValueTypeFileAddress)
                                     {
                                         lldb::addr_t file_addr = location_result.GetScalar().ULongLong();
                                         lldb::addr_t byte_size = 1;
                                         if (var_sp->GetType())
                                             byte_size = var_sp->GetType()->GetByteSize();
                                         m_global_aranges_ap->Append(GlobalVariableMap::Entry(file_addr, byte_size, var_sp.get()));

lldb/trunk/source/Target/StackFrame.cpp

if (m_flags.IsClear(GOT_FRAME_BASE))
 
             m_flags.Set(GOT_FRAME_BASE);
             ExecutionContext exe_ctx (shared_from_this());
             Value expr_value;
             addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
             if (m_sc.function->GetFrameBaseExpression().IsLocationList())
                 loclist_base_addr = m_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (exe_ctx.GetTargetPtr());
 
-            if (!m_sc.function->GetFrameBaseExpression().Evaluate(&exe_ctx, nullptr, nullptr, nullptr, loclist_base_addr,
-                                                                  nullptr, expr_value, &m_frame_base_error))
+            if (m_sc.function->GetFrameBaseExpression().Evaluate(&exe_ctx,
+                                                                 nullptr,
+                                                                 nullptr,
+                                                                 nullptr,
+                                                                 loclist_base_addr,
+                                                                 nullptr,
+                                                                 nullptr,
+                                                                 expr_value,
+                                                                 &m_frame_base_error) == false)
             {
                 // We should really have an error if evaluate returns, but in case
                 // we don't, lets set the error to something at least.
                 if (m_frame_base_error.Success())
                     m_frame_base_error.SetErrorString("Evaluation of the frame base expression failed.");
             }
             else
             {