contrib/llvm/tools/lldb/source/Core/ValueObjectDynamicValue.cpp

   1 //===-- ValueObjectDynamicValue.cpp ---------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10
  11 #include "lldb/Core/ValueObjectDynamicValue.h"
  12
  13 // C Includes
  14 // C++ Includes
  15 // Other libraries and framework includes
  16 // Project includes
  17 #include "lldb/Core/Log.h"
  18 #include "lldb/Core/Module.h"
  19 #include "lldb/Core/ValueObjectList.h"
  20 #include "lldb/Core/Value.h"
  21 #include "lldb/Core/ValueObject.h"
  22
  23 #include "lldb/Symbol/ClangASTType.h"
  24 #include "lldb/Symbol/ObjectFile.h"
  25 #include "lldb/Symbol/SymbolContext.h"
  26 #include "lldb/Symbol/Type.h"
  27 #include "lldb/Symbol/Variable.h"
  28
  29 #include "lldb/Target/ExecutionContext.h"
  30 #include "lldb/Target/LanguageRuntime.h"
  31 #include "lldb/Target/Process.h"
  32 #include "lldb/Target/RegisterContext.h"
  33 #include "lldb/Target/Target.h"
  34 #include "lldb/Target/Thread.h"
  35
  36 using namespace lldb_private;
  37
  38 ValueObjectDynamicValue::ValueObjectDynamicValue (ValueObject &parent, lldb::DynamicValueType use_dynamic) :
  39     ValueObject(parent),
  40     m_address (),
  41     m_dynamic_type_info(),
  42     m_use_dynamic (use_dynamic)
  43 {
  44     SetName (parent.GetName());
  45 }
  46
  47 ValueObjectDynamicValue::~ValueObjectDynamicValue()
  48 {
  49     m_owning_valobj_sp.reset();
  50 }
  51
  52 ClangASTType
  53 ValueObjectDynamicValue::GetClangTypeImpl ()
  54 {
  55     if (m_dynamic_type_info.HasTypeSP())
  56         return m_value.GetClangType();
  57     else
  58         return m_parent->GetClangType();
  59 }
  60
  61 ConstString
  62 ValueObjectDynamicValue::GetTypeName()
  63 {
  64     const bool success = UpdateValueIfNeeded(false);
  65     if (success)
  66     {
  67         if (m_dynamic_type_info.HasTypeSP())
  68             return GetClangType().GetConstTypeName();
  69         if (m_dynamic_type_info.HasName())
  70             return m_dynamic_type_info.GetName();
  71     }
  72     return m_parent->GetTypeName();
  73 }
  74
  75 ConstString
  76 ValueObjectDynamicValue::GetQualifiedTypeName()
  77 {
  78     const bool success = UpdateValueIfNeeded(false);
  79     if (success)
  80     {
  81         if (m_dynamic_type_info.HasTypeSP())
  82             return GetClangType().GetConstQualifiedTypeName ();
  83         if (m_dynamic_type_info.HasName())
  84             return m_dynamic_type_info.GetName();
  85     }
  86     return m_parent->GetTypeName();
  87 }
  88
  89 size_t
  90 ValueObjectDynamicValue::CalculateNumChildren()
  91 {
  92     const bool success = UpdateValueIfNeeded(false);
  93     if (success && m_dynamic_type_info.HasTypeSP())
  94         return GetClangType().GetNumChildren (true);
  95     else
  96         return m_parent->GetNumChildren();
  97 }
  98
  99 uint64_t
 100 ValueObjectDynamicValue::GetByteSize()
 101 {
 102     const bool success = UpdateValueIfNeeded(false);
 103     if (success && m_dynamic_type_info.HasTypeSP())
 104         return m_value.GetValueByteSize(NULL);
 105     else
 106         return m_parent->GetByteSize();
 107 }
 108
 109 lldb::ValueType
 110 ValueObjectDynamicValue::GetValueType() const
 111 {
 112     return m_parent->GetValueType();
 113 }
 114
 115 bool
 116 ValueObjectDynamicValue::UpdateValue ()
 117 {
 118     SetValueIsValid (false);
 119     m_error.Clear();
 120
 121     if (!m_parent->UpdateValueIfNeeded(false))
 122     {
 123         // The dynamic value failed to get an error, pass the error along
 124         if (m_error.Success() && m_parent->GetError().Fail())
 125             m_error = m_parent->GetError();
 126         return false;
 127     }
 128
 129     // Setting our type_sp to NULL will route everything back through our
 130     // parent which is equivalent to not using dynamic values.
 131     if (m_use_dynamic == lldb::eNoDynamicValues)
 132     {
 133         m_dynamic_type_info.Clear();
 134         return true;
 135     }
 136
 137     ExecutionContext exe_ctx (GetExecutionContextRef());
 138     Target *target = exe_ctx.GetTargetPtr();
 139     if (target)
 140     {
 141         m_data.SetByteOrder(target->GetArchitecture().GetByteOrder());
 142         m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
 143     }
 144
 145     // First make sure our Type and/or Address haven't changed:
 146     Process *process = exe_ctx.GetProcessPtr();
 147     if (!process)
 148         return false;
 149
 150     TypeAndOrName class_type_or_name;
 151     Address dynamic_address;
 152     bool found_dynamic_type = false;
 153
 154     lldb::LanguageType known_type = m_parent->GetObjectRuntimeLanguage();
 155     if (known_type != lldb::eLanguageTypeUnknown && known_type != lldb::eLanguageTypeC)
 156     {
 157         LanguageRuntime *runtime = process->GetLanguageRuntime (known_type);
 158         if (runtime)
 159             found_dynamic_type = runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address);
 160     }
 161     else
 162     {
 163         LanguageRuntime *cpp_runtime = process->GetLanguageRuntime (lldb::eLanguageTypeC_plus_plus);
 164         if (cpp_runtime)
 165             found_dynamic_type = cpp_runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address);
 166
 167         if (!found_dynamic_type)
 168         {
 169             LanguageRuntime *objc_runtime = process->GetLanguageRuntime (lldb::eLanguageTypeObjC);
 170             if (objc_runtime)
 171                 found_dynamic_type = objc_runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address);
 172         }
 173     }
 174
 175     // Getting the dynamic value may have run the program a bit, and so marked us as needing updating, but we really
 176     // don't...
 177
 178     m_update_point.SetUpdated();
 179
 180     // If we don't have a dynamic type, then make ourselves just a echo of our parent.
 181     // Or we could return false, and make ourselves an echo of our parent?
 182     if (!found_dynamic_type)
 183     {
 184         if (m_dynamic_type_info)
 185             SetValueDidChange(true);
 186         ClearDynamicTypeInformation();
 187         m_dynamic_type_info.Clear();
 188         m_value = m_parent->GetValue();
 189         m_error = m_value.GetValueAsData (&exe_ctx, m_data, 0, GetModule().get());
 190         return m_error.Success();
 191     }
 192
 193     Value old_value(m_value);
 194
 195     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
 196
 197     bool has_changed_type = false;
 198
 199     if (!m_dynamic_type_info)
 200     {
 201         m_dynamic_type_info = class_type_or_name;
 202         has_changed_type = true;
 203     }
 204     else if (class_type_or_name != m_dynamic_type_info)
 205     {
 206         // We are another type, we need to tear down our children...
 207         m_dynamic_type_info = class_type_or_name;
 208         SetValueDidChange (true);
 209         has_changed_type = true;
 210     }
 211
 212     if (has_changed_type)
 213         ClearDynamicTypeInformation ();
 214
 215     if (!m_address.IsValid() || m_address != dynamic_address)
 216     {
 217         if (m_address.IsValid())
 218             SetValueDidChange (true);
 219
 220         // We've moved, so we should be fine...
 221         m_address = dynamic_address;
 222         lldb::TargetSP target_sp (GetTargetSP());
 223         lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get());
 224         m_value.GetScalar() = load_address;
 225     }
 226
 227     ClangASTType corrected_type;
 228     if (m_dynamic_type_info.HasTypeSP())
 229     {
 230         // The type will always be the type of the dynamic object.  If our parent's type was a pointer,
 231         // then our type should be a pointer to the type of the dynamic object.  If a reference, then the original type
 232         // should be okay...
 233         ClangASTType orig_type = m_dynamic_type_info.GetTypeSP()->GetClangForwardType();
 234         corrected_type = orig_type;
 235         if (m_parent->IsPointerType())
 236             corrected_type = orig_type.GetPointerType ();
 237         else if (m_parent->IsPointerOrReferenceType())
 238             corrected_type = orig_type.GetLValueReferenceType ();
 239     }
 240     else /*if (m_dynamic_type_info.HasName())*/
 241     {
 242         // If we are here we need to adjust our dynamic type name to include the correct & or * symbol
 243         std::string type_name_buf (m_dynamic_type_info.GetName().GetCString());
 244         if (m_parent->IsPointerType())
 245             type_name_buf.append(" *");
 246         else if (m_parent->IsPointerOrReferenceType())
 247             type_name_buf.append(" &");
 248         corrected_type = m_parent->GetClangType();
 249         m_dynamic_type_info.SetName(type_name_buf.c_str());
 250     }
 251
 252     //m_value.SetContext (Value::eContextTypeClangType, corrected_type);
 253     m_value.SetClangType (corrected_type);
 254
 255     // Our address is the location of the dynamic type stored in memory.  It isn't a load address,
 256     // because we aren't pointing to the LOCATION that stores the pointer to us, we're pointing to us...
 257     m_value.SetValueType(Value::eValueTypeScalar);
 258
 259     if (has_changed_type && log)
 260         log->Printf("[%s %p] has a new dynamic type %s",
 261                     GetName().GetCString(),
 262                     this,
 263                     GetTypeName().GetCString());
 264
 265     if (m_address.IsValid() && m_dynamic_type_info)
 266     {
 267         // The variable value is in the Scalar value inside the m_value.
 268         // We can point our m_data right to it.
 269         m_error = m_value.GetValueAsData (&exe_ctx, m_data, 0, GetModule().get());
 270         if (m_error.Success())
 271         {
 272             if (GetClangType().IsAggregateType ())
 273             {
 274                 // this value object represents an aggregate type whose
 275                 // children have values, but this object does not. So we
 276                 // say we are changed if our location has changed.
 277                 SetValueDidChange (m_value.GetValueType() != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar());
 278             }
 279
 280             SetValueIsValid (true);
 281             return true;
 282         }
 283     }
 284
 285     // We get here if we've failed above...
 286     SetValueIsValid (false);
 287     return false;
 288 }
 289
 290
 291
 292 bool
 293 ValueObjectDynamicValue::IsInScope ()
 294 {
 295     return m_parent->IsInScope();
 296 }
 297
 298 bool
 299 ValueObjectDynamicValue::SetValueFromCString (const char *value_str, Error& error)
 300 {
 301     if (!UpdateValueIfNeeded(false))
 302     {
 303         error.SetErrorString("unable to read value");
 304         return false;
 305     }
 306
 307     uint64_t my_value = GetValueAsUnsigned(UINT64_MAX);
 308     uint64_t parent_value = m_parent->GetValueAsUnsigned(UINT64_MAX);
 309
 310     if (my_value == UINT64_MAX || parent_value == UINT64_MAX)
 311     {
 312         error.SetErrorString("unable to read value");
 313         return false;
 314     }
 315
 316     // if we are at an offset from our parent, in order to set ourselves correctly we would need
 317     // to change the new value so that it refers to the correct dynamic type. we choose not to deal
 318     // with that - if anything more than a value overwrite is required, you should be using the
 319     // expression parser instead of the value editing facility
 320     if (my_value != parent_value)
 321     {
 322         // but NULL'ing out a value should always be allowed
 323         if (strcmp(value_str,"0"))
 324         {
 325             error.SetErrorString("unable to modify dynamic value, use 'expression' command");
 326             return false;
 327         }
 328     }
 329
 330     bool ret_val = m_parent->SetValueFromCString(value_str,error);
 331     SetNeedsUpdate();
 332     return ret_val;
 333 }
 334
 335 bool
 336 ValueObjectDynamicValue::SetData (DataExtractor &data, Error &error)
 337 {
 338     if (!UpdateValueIfNeeded(false))
 339     {
 340         error.SetErrorString("unable to read value");
 341         return false;
 342     }
 343
 344     uint64_t my_value = GetValueAsUnsigned(UINT64_MAX);
 345     uint64_t parent_value = m_parent->GetValueAsUnsigned(UINT64_MAX);
 346
 347     if (my_value == UINT64_MAX || parent_value == UINT64_MAX)
 348     {
 349         error.SetErrorString("unable to read value");
 350         return false;
 351     }
 352
 353     // if we are at an offset from our parent, in order to set ourselves correctly we would need
 354     // to change the new value so that it refers to the correct dynamic type. we choose not to deal
 355     // with that - if anything more than a value overwrite is required, you should be using the
 356     // expression parser instead of the value editing facility
 357     if (my_value != parent_value)
 358     {
 359         // but NULL'ing out a value should always be allowed
 360         lldb::offset_t offset = 0;
 361
 362         if (data.GetPointer(&offset) != 0)
 363         {
 364             error.SetErrorString("unable to modify dynamic value, use 'expression' command");
 365             return false;
 366         }
 367     }
 368
 369     bool ret_val = m_parent->SetData(data, error);
 370     SetNeedsUpdate();
 371     return ret_val;
 372 }