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