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

   1 //===-- ValueObjectVariable.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/ValueObjectVariable.h"
  12
  13 // C Includes
  14 // C++ Includes
  15 // Other libraries and framework includes
  16 // Project includes
  17 #include "lldb/Core/Module.h"
  18 #include "lldb/Core/RegisterValue.h"
  19 #include "lldb/Core/ValueObjectList.h"
  20 #include "lldb/Core/Value.h"
  21
  22 #include "lldb/Symbol/Function.h"
  23 #include "lldb/Symbol/ObjectFile.h"
  24 #include "lldb/Symbol/SymbolContext.h"
  25 #include "lldb/Symbol/SymbolContextScope.h"
  26 #include "lldb/Symbol/Type.h"
  27 #include "lldb/Symbol/Variable.h"
  28
  29 #include "lldb/Target/ExecutionContext.h"
  30 #include "lldb/Target/Process.h"
  31 #include "lldb/Target/RegisterContext.h"
  32 #include "lldb/Target/Target.h"
  33 #include "lldb/Target/Thread.h"
  34
  35
  36 using namespace lldb_private;
  37
  38 lldb::ValueObjectSP
  39 ValueObjectVariable::Create (ExecutionContextScope *exe_scope, const lldb::VariableSP &var_sp)
  40 {
  41     return (new ValueObjectVariable (exe_scope, var_sp))->GetSP();
  42 }
  43
  44 ValueObjectVariable::ValueObjectVariable (ExecutionContextScope *exe_scope, const lldb::VariableSP &var_sp) :
  45     ValueObject(exe_scope),
  46     m_variable_sp(var_sp)
  47 {
  48     // Do not attempt to construct one of these objects with no variable!
  49     assert (m_variable_sp.get() != NULL);
  50     m_name = var_sp->GetName();
  51 }
  52
  53 ValueObjectVariable::~ValueObjectVariable()
  54 {
  55 }
  56
  57 ClangASTType
  58 ValueObjectVariable::GetClangTypeImpl ()
  59 {
  60     Type *var_type = m_variable_sp->GetType();
  61     if (var_type)
  62         return var_type->GetClangForwardType();
  63     return ClangASTType();
  64 }
  65
  66 ConstString
  67 ValueObjectVariable::GetTypeName()
  68 {
  69     Type * var_type = m_variable_sp->GetType();
  70     if (var_type)
  71         return var_type->GetName();
  72     return ConstString();
  73 }
  74
  75 ConstString
  76 ValueObjectVariable::GetQualifiedTypeName()
  77 {
  78     Type * var_type = m_variable_sp->GetType();
  79     if (var_type)
  80         return var_type->GetQualifiedName();
  81     return ConstString();
  82 }
  83
  84 size_t
  85 ValueObjectVariable::CalculateNumChildren()
  86 {
  87     ClangASTType type(GetClangType());
  88
  89     if (!type.IsValid())
  90         return 0;
  91
  92     const bool omit_empty_base_classes = true;
  93     return type.GetNumChildren(omit_empty_base_classes);
  94 }
  95
  96 uint64_t
  97 ValueObjectVariable::GetByteSize()
  98 {
  99     ClangASTType type(GetClangType());
 100
 101     if (!type.IsValid())
 102         return 0;
 103
 104     return type.GetByteSize();
 105 }
 106
 107 lldb::ValueType
 108 ValueObjectVariable::GetValueType() const
 109 {
 110     if (m_variable_sp)
 111         return m_variable_sp->GetScope();
 112     return lldb::eValueTypeInvalid;
 113 }
 114
 115 bool
 116 ValueObjectVariable::UpdateValue ()
 117 {
 118     SetValueIsValid (false);
 119     m_error.Clear();
 120
 121     Variable *variable = m_variable_sp.get();
 122     DWARFExpression &expr = variable->LocationExpression();
 123
 124     if (variable->GetLocationIsConstantValueData())
 125     {
 126         // expr doesn't contain DWARF bytes, it contains the constant variable
 127         // value bytes themselves...
 128         if (expr.GetExpressionData(m_data))
 129             m_value.SetContext(Value::eContextTypeVariable, variable);
 130         else
 131             m_error.SetErrorString ("empty constant data");
 132         // constant bytes can't be edited - sorry
 133         m_resolved_value.SetContext(Value::eContextTypeInvalid, NULL);
 134     }
 135     else
 136     {
 137         lldb::addr_t loclist_base_load_addr = LLDB_INVALID_ADDRESS;
 138         ExecutionContext exe_ctx (GetExecutionContextRef());
 139
 140         Target *target = exe_ctx.GetTargetPtr();
 141         if (target)
 142         {
 143             m_data.SetByteOrder(target->GetArchitecture().GetByteOrder());
 144             m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
 145         }
 146
 147         if (expr.IsLocationList())
 148         {
 149             SymbolContext sc;
 150             variable->CalculateSymbolContext (&sc);
 151             if (sc.function)
 152                 loclist_base_load_addr = sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress (target);
 153         }
 154         Value old_value(m_value);
 155         if (expr.Evaluate (&exe_ctx, NULL, NULL, NULL, loclist_base_load_addr, NULL, m_value, &m_error))
 156         {
 157             m_resolved_value = m_value;
 158             m_value.SetContext(Value::eContextTypeVariable, variable);
 159
 160             ClangASTType clang_type = GetClangType();
 161             if (clang_type.IsValid())
 162                 m_value.SetClangType(clang_type);
 163
 164             Value::ValueType value_type = m_value.GetValueType();
 165
 166             switch (value_type)
 167             {
 168                 case Value::eValueTypeFileAddress:
 169                     SetAddressTypeOfChildren(eAddressTypeFile);
 170                     break;
 171                 case Value::eValueTypeHostAddress:
 172                     SetAddressTypeOfChildren(eAddressTypeHost);
 173                     break;
 174                 case Value::eValueTypeLoadAddress:
 175                 case Value::eValueTypeScalar:
 176                 case Value::eValueTypeVector:
 177                     SetAddressTypeOfChildren(eAddressTypeLoad);
 178                     break;
 179             }
 180
 181             switch (value_type)
 182             {
 183             case Value::eValueTypeVector:
 184                     // fall through
 185             case Value::eValueTypeScalar:
 186                 // The variable value is in the Scalar value inside the m_value.
 187                 // We can point our m_data right to it.
 188                 m_error = m_value.GetValueAsData (&exe_ctx, m_data, 0, GetModule().get());
 189                 break;
 190
 191             case Value::eValueTypeFileAddress:
 192             case Value::eValueTypeLoadAddress:
 193             case Value::eValueTypeHostAddress:
 194                 // The DWARF expression result was an address in the inferior
 195                 // process. If this variable is an aggregate type, we just need
 196                 // the address as the main value as all child variable objects
 197                 // will rely upon this location and add an offset and then read
 198                 // their own values as needed. If this variable is a simple
 199                 // type, we read all data for it into m_data.
 200                 // Make sure this type has a value before we try and read it
 201
 202                 // If we have a file address, convert it to a load address if we can.
 203                 Process *process = exe_ctx.GetProcessPtr();
 204                 if (value_type == Value::eValueTypeFileAddress && process && process->IsAlive())
 205                 {
 206                     lldb::addr_t file_addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
 207                     if (file_addr != LLDB_INVALID_ADDRESS)
 208                     {
 209                         SymbolContext var_sc;
 210                         variable->CalculateSymbolContext(&var_sc);
 211                         if (var_sc.module_sp)
 212                         {
 213                             ObjectFile *objfile = var_sc.module_sp->GetObjectFile();
 214                             if (objfile)
 215                             {
 216                                 Address so_addr(file_addr, objfile->GetSectionList());
 217                                 lldb::addr_t load_addr = so_addr.GetLoadAddress (target);
 218                                 if (load_addr != LLDB_INVALID_ADDRESS)
 219                                 {
 220                                     m_value.SetValueType(Value::eValueTypeLoadAddress);
 221                                     m_value.GetScalar() = load_addr;
 222                                 }
 223                             }
 224                         }
 225                     }
 226                 }
 227
 228                 if (GetClangType().IsAggregateType())
 229                 {
 230                     // this value object represents an aggregate type whose
 231                     // children have values, but this object does not. So we
 232                     // say we are changed if our location has changed.
 233                     SetValueDidChange (value_type != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar());
 234                 }
 235                 else
 236                 {
 237                     // Copy the Value and set the context to use our Variable
 238                     // so it can extract read its value into m_data appropriately
 239                     Value value(m_value);
 240                     value.SetContext(Value::eContextTypeVariable, variable);
 241                     m_error = value.GetValueAsData(&exe_ctx, m_data, 0, GetModule().get());
 242                 }
 243                 break;
 244             }
 245
 246             SetValueIsValid (m_error.Success());
 247         }
 248         else
 249         {
 250             // could not find location, won't allow editing
 251             m_resolved_value.SetContext(Value::eContextTypeInvalid, NULL);
 252         }
 253     }
 254     return m_error.Success();
 255 }
 256
 257
 258
 259 bool
 260 ValueObjectVariable::IsInScope ()
 261 {
 262     const ExecutionContextRef &exe_ctx_ref = GetExecutionContextRef();
 263     if (exe_ctx_ref.HasFrameRef())
 264     {
 265         ExecutionContext exe_ctx (exe_ctx_ref);
 266         StackFrame *frame = exe_ctx.GetFramePtr();
 267         if (frame)
 268         {
 269             return m_variable_sp->IsInScope (frame);
 270         }
 271         else
 272         {
 273             // This ValueObject had a frame at one time, but now we
 274             // can't locate it, so return false since we probably aren't
 275             // in scope.
 276             return false;
 277         }
 278     }
 279     // We have a variable that wasn't tied to a frame, which
 280     // means it is a global and is always in scope.
 281     return true;
 282
 283 }
 284
 285 lldb::ModuleSP
 286 ValueObjectVariable::GetModule()
 287 {
 288     if (m_variable_sp)
 289     {
 290         SymbolContextScope *sc_scope = m_variable_sp->GetSymbolContextScope();
 291         if (sc_scope)
 292         {
 293             return sc_scope->CalculateSymbolContextModule();
 294         }
 295     }
 296     return lldb::ModuleSP();
 297 }
 298
 299 SymbolContextScope *
 300 ValueObjectVariable::GetSymbolContextScope()
 301 {
 302     if (m_variable_sp)
 303         return m_variable_sp->GetSymbolContextScope();
 304     return NULL;
 305 }
 306
 307 bool
 308 ValueObjectVariable::GetDeclaration (Declaration &decl)
 309 {
 310     if (m_variable_sp)
 311     {
 312         decl = m_variable_sp->GetDeclaration();
 313         return true;
 314     }
 315     return false;
 316 }
 317
 318 const char *
 319 ValueObjectVariable::GetLocationAsCString ()
 320 {
 321     if (m_resolved_value.GetContextType() == Value::eContextTypeRegisterInfo)
 322         return GetLocationAsCStringImpl(m_resolved_value,
 323                                         m_data);
 324     else
 325         return ValueObject::GetLocationAsCString();
 326 }
 327
 328 bool
 329 ValueObjectVariable::SetValueFromCString (const char *value_str, Error& error)
 330 {
 331     if (!UpdateValueIfNeeded())
 332     {
 333         error.SetErrorString("unable to update value before writing");
 334         return false;
 335     }
 336
 337     if (m_resolved_value.GetContextType() == Value::eContextTypeRegisterInfo)
 338     {
 339         RegisterInfo *reg_info = m_resolved_value.GetRegisterInfo();
 340         ExecutionContext exe_ctx(GetExecutionContextRef());
 341         RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
 342         RegisterValue reg_value;
 343         if (!reg_info || !reg_ctx)
 344         {
 345             error.SetErrorString("unable to retrieve register info");
 346             return false;
 347         }
 348         error = reg_value.SetValueFromCString(reg_info, value_str);
 349         if (error.Fail())
 350             return false;
 351         if (reg_ctx->WriteRegister (reg_info, reg_value))
 352         {
 353             SetNeedsUpdate();
 354             return true;
 355         }
 356         else
 357         {
 358             error.SetErrorString("unable to write back to register");
 359             return false;
 360         }
 361     }
 362     else
 363         return ValueObject::SetValueFromCString(value_str, error);
 364 }
 365
 366 bool
 367 ValueObjectVariable::SetData (DataExtractor &data, Error &error)
 368 {
 369     if (!UpdateValueIfNeeded())
 370     {
 371         error.SetErrorString("unable to update value before writing");
 372         return false;
 373     }
 374
 375     if (m_resolved_value.GetContextType() == Value::eContextTypeRegisterInfo)
 376     {
 377         RegisterInfo *reg_info = m_resolved_value.GetRegisterInfo();
 378         ExecutionContext exe_ctx(GetExecutionContextRef());
 379         RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();
 380         RegisterValue reg_value;
 381         if (!reg_info || !reg_ctx)
 382         {
 383             error.SetErrorString("unable to retrieve register info");
 384             return false;
 385         }
 386         error = reg_value.SetValueFromData(reg_info, data, 0, true);
 387         if (error.Fail())
 388             return false;
 389         if (reg_ctx->WriteRegister (reg_info, reg_value))
 390         {
 391             SetNeedsUpdate();
 392             return true;
 393         }
 394         else
 395         {
 396             error.SetErrorString("unable to write back to register");
 397             return false;
 398         }
 399     }
 400     else
 401         return ValueObject::SetData(data, error);
 402 }