bool ValueObjectDynamicValue::UpdateValue () { SetValueIsValid (false); m_error.Clear(); if (!m_parent->UpdateValueIfNeeded(false)) { // The dynamic value failed to get an error, pass the error along if (m_error.Success() && m_parent->GetError().Fail()) m_error = m_parent->GetError(); return false; } // Setting our type_sp to NULL will route everything back through our // parent which is equivalent to not using dynamic values. if (m_use_dynamic == lldb::eNoDynamicValues) { m_dynamic_type_info.Clear(); return true; } ExecutionContext exe_ctx (GetExecutionContextRef()); Target *target = exe_ctx.GetTargetPtr(); if (target) { m_data.SetByteOrder(target->GetArchitecture().GetByteOrder()); m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize()); } // First make sure our Type and/or Address haven't changed: Process *process = exe_ctx.GetProcessPtr(); if (!process) return false; TypeAndOrName class_type_or_name; Address dynamic_address; bool found_dynamic_type = false; lldb::LanguageType known_type = m_parent->GetObjectRuntimeLanguage(); if (known_type != lldb::eLanguageTypeUnknown && known_type != lldb::eLanguageTypeC) { LanguageRuntime *runtime = process->GetLanguageRuntime (known_type); if (runtime) found_dynamic_type = runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address); } else { LanguageRuntime *cpp_runtime = process->GetLanguageRuntime (lldb::eLanguageTypeC_plus_plus); if (cpp_runtime) found_dynamic_type = cpp_runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address); if (!found_dynamic_type) { LanguageRuntime *objc_runtime = process->GetLanguageRuntime (lldb::eLanguageTypeObjC); if (objc_runtime) found_dynamic_type = objc_runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address); } } // Getting the dynamic value may have run the program a bit, and so marked us as needing updating, but we really // don't... m_update_point.SetUpdated(); // If we don't have a dynamic type, then make ourselves just a echo of our parent. // Or we could return false, and make ourselves an echo of our parent? if (!found_dynamic_type) { if (m_dynamic_type_info) SetValueDidChange(true); ClearDynamicTypeInformation(); m_dynamic_type_info.Clear(); m_value = m_parent->GetValue(); m_error = m_value.GetValueAsData (&exe_ctx, GetClangAST(), m_data, 0, GetModule().get()); return m_error.Success(); } Value old_value(m_value); Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES)); bool has_changed_type = false; if (!m_dynamic_type_info) { m_dynamic_type_info = class_type_or_name; has_changed_type = true; } else if (class_type_or_name != m_dynamic_type_info) { // We are another type, we need to tear down our children... m_dynamic_type_info = class_type_or_name; SetValueDidChange (true); has_changed_type = true; } if (has_changed_type) ClearDynamicTypeInformation (); if (!m_address.IsValid() || m_address != dynamic_address) { if (m_address.IsValid()) SetValueDidChange (true); // We've moved, so we should be fine... m_address = dynamic_address; lldb::TargetSP target_sp (GetTargetSP()); lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get()); m_value.GetScalar() = load_address; } lldb::clang_type_t corrected_type; if (m_dynamic_type_info.HasTypeSP()) { // The type will always be the type of the dynamic object. If our parent's type was a pointer, // then our type should be a pointer to the type of the dynamic object. If a reference, then the original type // should be okay... lldb::clang_type_t orig_type; clang::ASTContext* ast; orig_type = m_dynamic_type_info.GetTypeSP()->GetClangForwardType(); ast = m_dynamic_type_info.GetTypeSP()->GetClangAST(); corrected_type = orig_type; if (m_parent->IsPointerType()) corrected_type = ClangASTContext::CreatePointerType (ast, orig_type); else if (m_parent->IsPointerOrReferenceType()) corrected_type = ClangASTContext::CreateLValueReferenceType (ast, orig_type); } else /*if (m_dynamic_type_info.HasName())*/ { // If we are here we need to adjust our dynamic type name to include the correct & or * symbol std::string type_name_buf (m_dynamic_type_info.GetName().GetCString()); if (m_parent->IsPointerType()) type_name_buf.append(" *"); else if (m_parent->IsPointerOrReferenceType()) type_name_buf.append(" &"); corrected_type = m_parent->GetClangType(); m_dynamic_type_info.SetName(type_name_buf.c_str()); } m_value.SetContext (Value::eContextTypeClangType, corrected_type); // Our address is the location of the dynamic type stored in memory. It isn't a load address, // because we aren't pointing to the LOCATION that stores the pointer to us, we're pointing to us... m_value.SetValueType(Value::eValueTypeScalar); if (has_changed_type && log) log->Printf("[%s %p] has a new dynamic type %s", GetName().GetCString(), this, GetTypeName().GetCString()); if (m_address.IsValid() && m_dynamic_type_info) { // The variable value is in the Scalar value inside the m_value. // We can point our m_data right to it. m_error = m_value.GetValueAsData (&exe_ctx, GetClangAST(), m_data, 0, GetModule().get()); if (m_error.Success()) { if (ClangASTContext::IsAggregateType (GetClangType())) { // this value object represents an aggregate type whose // children have values, but this object does not. So we // say we are changed if our location has changed. SetValueDidChange (m_value.GetValueType() != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar()); } SetValueIsValid (true); return true; } } // We get here if we've failed above... SetValueIsValid (false); return false; }
bool ValueObjectDynamicValue::UpdateValue() { SetValueIsValid(false); m_error.Clear(); if (!m_parent->UpdateValueIfNeeded(false)) { // The dynamic value failed to get an error, pass the error along if (m_error.Success() && m_parent->GetError().Fail()) m_error = m_parent->GetError(); return false; } // Setting our type_sp to NULL will route everything back through our parent // which is equivalent to not using dynamic values. if (m_use_dynamic == lldb::eNoDynamicValues) { m_dynamic_type_info.Clear(); return true; } ExecutionContext exe_ctx(GetExecutionContextRef()); Target *target = exe_ctx.GetTargetPtr(); if (target) { m_data.SetByteOrder(target->GetArchitecture().GetByteOrder()); m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize()); } // First make sure our Type and/or Address haven't changed: Process *process = exe_ctx.GetProcessPtr(); if (!process) return false; TypeAndOrName class_type_or_name; Address dynamic_address; bool found_dynamic_type = false; Value::ValueType value_type; LanguageRuntime *runtime = nullptr; lldb::LanguageType known_type = m_parent->GetObjectRuntimeLanguage(); if (known_type != lldb::eLanguageTypeUnknown && known_type != lldb::eLanguageTypeC) { runtime = process->GetLanguageRuntime(known_type); if (runtime) found_dynamic_type = runtime->GetDynamicTypeAndAddress( *m_parent, m_use_dynamic, class_type_or_name, dynamic_address, value_type); } else { runtime = process->GetLanguageRuntime(lldb::eLanguageTypeC_plus_plus); if (runtime) found_dynamic_type = runtime->GetDynamicTypeAndAddress( *m_parent, m_use_dynamic, class_type_or_name, dynamic_address, value_type); if (!found_dynamic_type) { runtime = process->GetLanguageRuntime(lldb::eLanguageTypeObjC); if (runtime) found_dynamic_type = runtime->GetDynamicTypeAndAddress( *m_parent, m_use_dynamic, class_type_or_name, dynamic_address, value_type); } } // Getting the dynamic value may have run the program a bit, and so marked us // as needing updating, but we really don't... m_update_point.SetUpdated(); if (runtime && found_dynamic_type) { if (class_type_or_name.HasType()) { m_type_impl = TypeImpl(m_parent->GetCompilerType(), runtime->FixUpDynamicType(class_type_or_name, *m_parent) .GetCompilerType()); } else { m_type_impl.Clear(); } } else { m_type_impl.Clear(); } // If we don't have a dynamic type, then make ourselves just a echo of our // parent. Or we could return false, and make ourselves an echo of our // parent? if (!found_dynamic_type) { if (m_dynamic_type_info) SetValueDidChange(true); ClearDynamicTypeInformation(); m_dynamic_type_info.Clear(); m_value = m_parent->GetValue(); m_error = m_value.GetValueAsData(&exe_ctx, m_data, 0, GetModule().get()); return m_error.Success(); } Value old_value(m_value); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES)); bool has_changed_type = false; if (!m_dynamic_type_info) { m_dynamic_type_info = class_type_or_name; has_changed_type = true; } else if (class_type_or_name != m_dynamic_type_info) { // We are another type, we need to tear down our children... m_dynamic_type_info = class_type_or_name; SetValueDidChange(true); has_changed_type = true; } if (has_changed_type) ClearDynamicTypeInformation(); if (!m_address.IsValid() || m_address != dynamic_address) { if (m_address.IsValid()) SetValueDidChange(true); // We've moved, so we should be fine... m_address = dynamic_address; lldb::TargetSP target_sp(GetTargetSP()); lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get()); m_value.GetScalar() = load_address; } if (runtime) m_dynamic_type_info = runtime->FixUpDynamicType(m_dynamic_type_info, *m_parent); // m_value.SetContext (Value::eContextTypeClangType, corrected_type); m_value.SetCompilerType(m_dynamic_type_info.GetCompilerType()); m_value.SetValueType(value_type); if (has_changed_type && log) log->Printf("[%s %p] has a new dynamic type %s", GetName().GetCString(), static_cast<void *>(this), GetTypeName().GetCString()); if (m_address.IsValid() && m_dynamic_type_info) { // The variable value is in the Scalar value inside the m_value. We can // point our m_data right to it. m_error = m_value.GetValueAsData(&exe_ctx, m_data, 0, GetModule().get()); if (m_error.Success()) { if (!CanProvideValue()) { // this value object represents an aggregate type whose children have // values, but this object does not. So we say we are changed if our // location has changed. SetValueDidChange(m_value.GetValueType() != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar()); } SetValueIsValid(true); return true; } } // We get here if we've failed above... SetValueIsValid(false); return false; }