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     const bool success = UpdateValueIfNeeded(false);
  56     if (success)
  57     {
  58         if (m_dynamic_type_info.HasType())
  59             return m_value.GetClangType();
  60         else
  61             return m_parent->GetClangType();
  62     }
  63     return m_parent->GetClangType();
  64 }
  65
  66 ConstString
  67 ValueObjectDynamicValue::GetTypeName()
  68 {
  69     const bool success = UpdateValueIfNeeded(false);
  70     if (success)
  71     {
  72         if (m_dynamic_type_info.HasName())
  73             return m_dynamic_type_info.GetName();
  74     }
  75     return m_parent->GetTypeName();
  76 }
  77
  78 TypeImpl
  79 ValueObjectDynamicValue::GetTypeImpl ()
  80 {
  81     const bool success = UpdateValueIfNeeded(false);
  82     if (success && m_type_impl.IsValid())
  83     {
  84         return m_type_impl;
  85     }
  86     return m_parent->GetTypeImpl();
  87 }
  88
  89 ConstString
  90 ValueObjectDynamicValue::GetQualifiedTypeName()
  91 {
  92     const bool success = UpdateValueIfNeeded(false);
  93     if (success)
  94     {
  95         if (m_dynamic_type_info.HasName())
  96             return m_dynamic_type_info.GetName();
  97     }
  98     return m_parent->GetQualifiedTypeName();
  99 }
 100
 101 ConstString
 102 ValueObjectDynamicValue::GetDisplayTypeName()
 103 {
 104     const bool success = UpdateValueIfNeeded(false);
 105     if (success)
 106     {
 107         if (m_dynamic_type_info.HasType())
 108             return GetClangType().GetDisplayTypeName();
 109         if (m_dynamic_type_info.HasName())
 110             return m_dynamic_type_info.GetName();
 111     }
 112     return m_parent->GetDisplayTypeName();
 113 }
 114
 115 size_t
 116 ValueObjectDynamicValue::CalculateNumChildren()
 117 {
 118     const bool success = UpdateValueIfNeeded(false);
 119     if (success && m_dynamic_type_info.HasType())
 120         return GetClangType().GetNumChildren (true);
 121     else
 122         return m_parent->GetNumChildren();
 123 }
 124
 125 uint64_t
 126 ValueObjectDynamicValue::GetByteSize()
 127 {
 128     const bool success = UpdateValueIfNeeded(false);
 129     if (success && m_dynamic_type_info.HasType())
 130         return m_value.GetValueByteSize(nullptr);
 131     else
 132         return m_parent->GetByteSize();
 133 }
 134
 135 lldb::ValueType
 136 ValueObjectDynamicValue::GetValueType() const
 137 {
 138     return m_parent->GetValueType();
 139 }
 140
 141
 142 static TypeAndOrName
 143 FixupTypeAndOrName (const TypeAndOrName& type_andor_name,
 144                     ValueObject& parent)
 145 {
 146     TypeAndOrName ret(type_andor_name);
 147     if (type_andor_name.HasType())
 148     {
 149         // The type will always be the type of the dynamic object.  If our parent's type was a pointer,
 150         // then our type should be a pointer to the type of the dynamic object.  If a reference, then the original type
 151         // should be okay...
 152         ClangASTType orig_type = type_andor_name.GetClangASTType();
 153         ClangASTType corrected_type = orig_type;
 154         if (parent.IsPointerType())
 155             corrected_type = orig_type.GetPointerType ();
 156         else if (parent.IsPointerOrReferenceType())
 157             corrected_type = orig_type.GetLValueReferenceType ();
 158         ret.SetClangASTType(corrected_type);
 159     }
 160     else /*if (m_dynamic_type_info.HasName())*/
 161     {
 162         // If we are here we need to adjust our dynamic type name to include the correct & or * symbol
 163         std::string corrected_name (type_andor_name.GetName().GetCString());
 164         if (parent.IsPointerType())
 165             corrected_name.append(" *");
 166         else if (parent.IsPointerOrReferenceType())
 167             corrected_name.append(" &");
 168         // the parent type should be a correctly pointer'ed or referenc'ed type
 169         ret.SetClangASTType(parent.GetClangType());
 170         ret.SetName(corrected_name.c_str());
 171     }
 172     return ret;
 173 }
 174
 175 bool
 176 ValueObjectDynamicValue::UpdateValue ()
 177 {
 178     SetValueIsValid (false);
 179     m_error.Clear();
 180
 181     if (!m_parent->UpdateValueIfNeeded(false))
 182     {
 183         // The dynamic value failed to get an error, pass the error along
 184         if (m_error.Success() && m_parent->GetError().Fail())
 185             m_error = m_parent->GetError();
 186         return false;
 187     }
 188
 189     // Setting our type_sp to NULL will route everything back through our
 190     // parent which is equivalent to not using dynamic values.
 191     if (m_use_dynamic == lldb::eNoDynamicValues)
 192     {
 193         m_dynamic_type_info.Clear();
 194         return true;
 195     }
 196
 197     ExecutionContext exe_ctx (GetExecutionContextRef());
 198     Target *target = exe_ctx.GetTargetPtr();
 199     if (target)
 200     {
 201         m_data.SetByteOrder(target->GetArchitecture().GetByteOrder());
 202         m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
 203     }
 204
 205     // First make sure our Type and/or Address haven't changed:
 206     Process *process = exe_ctx.GetProcessPtr();
 207     if (!process)
 208         return false;
 209
 210     TypeAndOrName class_type_or_name;
 211     Address dynamic_address;
 212     bool found_dynamic_type = false;
 213
 214     lldb::LanguageType known_type = m_parent->GetObjectRuntimeLanguage();
 215     if (known_type != lldb::eLanguageTypeUnknown && known_type != lldb::eLanguageTypeC)
 216     {
 217         LanguageRuntime *runtime = process->GetLanguageRuntime (known_type);
 218         if (runtime)
 219             found_dynamic_type = runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address);
 220     }
 221     else
 222     {
 223         LanguageRuntime *cpp_runtime = process->GetLanguageRuntime (lldb::eLanguageTypeC_plus_plus);
 224         if (cpp_runtime)
 225             found_dynamic_type = cpp_runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address);
 226
 227         if (!found_dynamic_type)
 228         {
 229             LanguageRuntime *objc_runtime = process->GetLanguageRuntime (lldb::eLanguageTypeObjC);
 230             if (objc_runtime)
 231                 found_dynamic_type = objc_runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address);
 232         }
 233     }
 234
 235     // Getting the dynamic value may have run the program a bit, and so marked us as needing updating, but we really
 236     // don't...
 237
 238     m_update_point.SetUpdated();
 239
 240     if (found_dynamic_type)
 241     {
 242         if (class_type_or_name.HasType())
 243         {
 244             m_type_impl = TypeImpl(m_parent->GetClangType(),FixupTypeAndOrName(class_type_or_name, *m_parent).GetClangASTType());
 245         }
 246         else
 247         {
 248             m_type_impl.Clear();
 249         }
 250     }
 251     else
 252     {
 253         m_type_impl.Clear();
 254     }
 255
 256     // If we don't have a dynamic type, then make ourselves just a echo of our parent.
 257     // Or we could return false, and make ourselves an echo of our parent?
 258     if (!found_dynamic_type)
 259     {
 260         if (m_dynamic_type_info)
 261             SetValueDidChange(true);
 262         ClearDynamicTypeInformation();
 263         m_dynamic_type_info.Clear();
 264         m_value = m_parent->GetValue();
 265         m_error = m_value.GetValueAsData (&exe_ctx, m_data, 0, GetModule().get());
 266         return m_error.Success();
 267     }
 268
 269     Value old_value(m_value);
 270
 271     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
 272
 273     bool has_changed_type = false;
 274
 275     if (!m_dynamic_type_info)
 276     {
 277         m_dynamic_type_info = class_type_or_name;
 278         has_changed_type = true;
 279     }
 280     else if (class_type_or_name != m_dynamic_type_info)
 281     {
 282         // We are another type, we need to tear down our children...
 283         m_dynamic_type_info = class_type_or_name;
 284         SetValueDidChange (true);
 285         has_changed_type = true;
 286     }
 287
 288     if (has_changed_type)
 289         ClearDynamicTypeInformation ();
 290
 291     if (!m_address.IsValid() || m_address != dynamic_address)
 292     {
 293         if (m_address.IsValid())
 294             SetValueDidChange (true);
 295
 296         // We've moved, so we should be fine...
 297         m_address = dynamic_address;
 298         lldb::TargetSP target_sp (GetTargetSP());
 299         lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get());
 300         m_value.GetScalar() = load_address;
 301     }
 302
 303     m_dynamic_type_info = FixupTypeAndOrName(m_dynamic_type_info, *m_parent);
 304
 305     //m_value.SetContext (Value::eContextTypeClangType, corrected_type);
 306     m_value.SetClangType (m_dynamic_type_info.GetClangASTType());
 307
 308     // Our address is the location of the dynamic type stored in memory.  It isn't a load address,
 309     // because we aren't pointing to the LOCATION that stores the pointer to us, we're pointing to us...
 310     m_value.SetValueType(Value::eValueTypeScalar);
 311
 312     if (has_changed_type && log)
 313         log->Printf("[%s %p] has a new dynamic type %s", GetName().GetCString(),
 314                     static_cast<void*>(this), GetTypeName().GetCString());
 315
 316     if (m_address.IsValid() && m_dynamic_type_info)
 317     {
 318         // The variable value is in the Scalar value inside the m_value.
 319         // We can point our m_data right to it.
 320         m_error = m_value.GetValueAsData (&exe_ctx, m_data, 0, GetModule().get());
 321         if (m_error.Success())
 322         {
 323             if (!CanProvideValue())
 324             {
 325                 // this value object represents an aggregate type whose
 326                 // children have values, but this object does not. So we
 327                 // say we are changed if our location has changed.
 328                 SetValueDidChange (m_value.GetValueType() != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar());
 329             }
 330
 331             SetValueIsValid (true);
 332             return true;
 333         }
 334     }
 335
 336     // We get here if we've failed above...
 337     SetValueIsValid (false);
 338     return false;
 339 }
 340
 341
 342
 343 bool
 344 ValueObjectDynamicValue::IsInScope ()
 345 {
 346     return m_parent->IsInScope();
 347 }
 348
 349 bool
 350 ValueObjectDynamicValue::SetValueFromCString (const char *value_str, Error& error)
 351 {
 352     if (!UpdateValueIfNeeded(false))
 353     {
 354         error.SetErrorString("unable to read value");
 355         return false;
 356     }
 357
 358     uint64_t my_value = GetValueAsUnsigned(UINT64_MAX);
 359     uint64_t parent_value = m_parent->GetValueAsUnsigned(UINT64_MAX);
 360
 361     if (my_value == UINT64_MAX || parent_value == UINT64_MAX)
 362     {
 363         error.SetErrorString("unable to read value");
 364         return false;
 365     }
 366
 367     // if we are at an offset from our parent, in order to set ourselves correctly we would need
 368     // to change the new value so that it refers to the correct dynamic type. we choose not to deal
 369     // with that - if anything more than a value overwrite is required, you should be using the
 370     // expression parser instead of the value editing facility
 371     if (my_value != parent_value)
 372     {
 373         // but NULL'ing out a value should always be allowed
 374         if (strcmp(value_str,"0"))
 375         {
 376             error.SetErrorString("unable to modify dynamic value, use 'expression' command");
 377             return false;
 378         }
 379     }
 380
 381     bool ret_val = m_parent->SetValueFromCString(value_str,error);
 382     SetNeedsUpdate();
 383     return ret_val;
 384 }
 385
 386 bool
 387 ValueObjectDynamicValue::SetData (DataExtractor &data, Error &error)
 388 {
 389     if (!UpdateValueIfNeeded(false))
 390     {
 391         error.SetErrorString("unable to read value");
 392         return false;
 393     }
 394
 395     uint64_t my_value = GetValueAsUnsigned(UINT64_MAX);
 396     uint64_t parent_value = m_parent->GetValueAsUnsigned(UINT64_MAX);
 397
 398     if (my_value == UINT64_MAX || parent_value == UINT64_MAX)
 399     {
 400         error.SetErrorString("unable to read value");
 401         return false;
 402     }
 403
 404     // if we are at an offset from our parent, in order to set ourselves correctly we would need
 405     // to change the new value so that it refers to the correct dynamic type. we choose not to deal
 406     // with that - if anything more than a value overwrite is required, you should be using the
 407     // expression parser instead of the value editing facility
 408     if (my_value != parent_value)
 409     {
 410         // but NULL'ing out a value should always be allowed
 411         lldb::offset_t offset = 0;
 412
 413         if (data.GetPointer(&offset) != 0)
 414         {
 415             error.SetErrorString("unable to modify dynamic value, use 'expression' command");
 416             return false;
 417         }
 418     }
 419
 420     bool ret_val = m_parent->SetData(data, error);
 421     SetNeedsUpdate();
 422     return ret_val;
 423 }