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