//===-- ValueObjectVariable.cpp -------------------------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

#include "lldb/Core/ValueObjectVariable.h"

#include "lldb/Core/Address.h"

#include "lldb/Core/AddressRange.h"

#include "lldb/Core/Declaration.h"

#include "lldb/Core/Module.h"

#include "lldb/Core/Value.h"

#include "lldb/Expression/DWARFExpressionList.h"

#include "lldb/Symbol/Function.h"

#include "lldb/Symbol/ObjectFile.h"

#include "lldb/Symbol/SymbolContext.h"

#include "lldb/Symbol/SymbolContextScope.h"

#include "lldb/Symbol/Type.h"

#include "lldb/Symbol/Variable.h"

#include "lldb/Target/ExecutionContext.h"

#include "lldb/Target/Process.h"

#include "lldb/Target/RegisterContext.h"

#include "lldb/Target/Target.h"

#include "lldb/Utility/DataExtractor.h"

#include "lldb/Utility/RegisterValue.h"

#include "lldb/Utility/Scalar.h"

#include "lldb/Utility/Status.h"

#include "lldb/lldb-private-enumerations.h"

#include "lldb/lldb-types.h"

#include "llvm/ADT/StringRef.h"

#include <cassert>

#include <memory>

#include <optional>

namespace lldb_private {

class ExecutionContextScope;

}

namespace lldb_private {

class StackFrame;

}

namespace lldb_private {

struct RegisterInfo;

}

using namespace lldb_private;

lldb::ValueObjectSP

ValueObjectVariable::Create(ExecutionContextScope *exe_scope,

                            const lldb::VariableSP &var_sp) {

  auto manager_sp = ValueObjectManager::Create();

  return (new ValueObjectVariable(exe_scope, *manager_sp, var_sp))->GetSP();

}

ValueObjectVariable::ValueObjectVariable(ExecutionContextScope *exe_scope,

                                         ValueObjectManager &manager,

                                         const lldb::VariableSP &var_sp)

    : ValueObject(exe_scope, manager), m_variable_sp(var_sp) {

  // Do not attempt to construct one of these objects with no variable!

  assert(m_variable_sp.get() != nullptr);

  m_name = var_sp->GetName();

}

ValueObjectVariable::~ValueObjectVariable() = default;

CompilerType ValueObjectVariable::GetCompilerTypeImpl() {

  Type *var_type = m_variable_sp->GetType();

  if (var_type)

    return var_type->GetForwardCompilerType();

  return CompilerType();

}

ConstString ValueObjectVariable::GetTypeName() {

  Type *var_type = m_variable_sp->GetType();

  if (var_type)

    return var_type->GetName();

  return ConstString();

}

ConstString ValueObjectVariable::GetDisplayTypeName() {

  Type *var_type = m_variable_sp->GetType();

  if (var_type)

    return var_type->GetForwardCompilerType().GetDisplayTypeName();

  return ConstString();

}

ConstString ValueObjectVariable::GetQualifiedTypeName() {

  Type *var_type = m_variable_sp->GetType();

  if (var_type)

    return var_type->GetQualifiedName();

  return ConstString();

}

size_t ValueObjectVariable::CalculateNumChildren(uint32_t max) {

  CompilerType type(GetCompilerType());

  if (!type.IsValid())

    return 0;

  ExecutionContext exe_ctx(GetExecutionContextRef());

  const bool omit_empty_base_classes = true;

  auto child_count = type.GetNumChildren(omit_empty_base_classes, &exe_ctx);

  return child_count <= max ? child_count : 
max0
;

}

std::optional<uint64_t> ValueObjectVariable::GetByteSize() {

  ExecutionContext exe_ctx(GetExecutionContextRef());

  CompilerType type(GetCompilerType());

  if (!type.IsValid())

    return {};

  return type.GetByteSize(exe_ctx.GetBestExecutionContextScope());

}

lldb::ValueType ValueObjectVariable::GetValueType() const {

  if (m_variable_sp)

    return m_variable_sp->GetScope();

  return lldb::eValueTypeInvalid;

}

bool ValueObjectVariable::UpdateValue() {

  SetValueIsValid(false);

  m_error.Clear();

  Variable *variable = m_variable_sp.get();

  DWARFExpressionList &expr_list = variable->LocationExpressionList();

  if (variable->GetLocationIsConstantValueData()) {

    // expr doesn't contain DWARF bytes, it contains the constant variable

    // value bytes themselves...

    if (expr_list.GetExpressionData(m_data)) {

      if (m_data.GetDataStart() && m_data.GetByteSize())

        m_value.SetBytes(m_data.GetDataStart(), m_data.GetByteSize());

      m_value.SetContext(Value::ContextType::Variable, variable);

    } else

      m_error.SetErrorString("empty constant data");

    // constant bytes can't be edited - sorry

    m_resolved_value.SetContext(Value::ContextType::Invalid, nullptr);

  } else {

    lldb::addr_t loclist_base_load_addr = LLDB_INVALID_ADDRESS;

    ExecutionContext exe_ctx(GetExecutionContextRef());

    Target *target = exe_ctx.GetTargetPtr();

    if (target) {

      m_data.SetByteOrder(target->GetArchitecture().GetByteOrder());

      m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());

    }

    if (!expr_list.IsAlwaysValidSingleExpr()) {

      SymbolContext sc;

      variable->CalculateSymbolContext(&sc);

      if (sc.function)

        loclist_base_load_addr =

            sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(

                target);

    }

    Value old_value(m_value);

    if (expr_list.Evaluate(&exe_ctx, nullptr, loclist_base_load_addr, nullptr,

                           nullptr, m_value, &m_error)) {

      m_resolved_value = m_value;

      m_value.SetContext(Value::ContextType::Variable, variable);

      CompilerType compiler_type = GetCompilerType();

      if (compiler_type.IsValid())

        m_value.SetCompilerType(compiler_type);

      Value::ValueType value_type = m_value.GetValueType();

      // The size of the buffer within m_value can be less than the size

      // prescribed by its type. E.g. this can happen when an expression only

      // partially describes an object (say, because it contains DW_OP_piece).

      //

      // In this case, grow m_value to the expected size. An alternative way to

      // handle this is to teach Value::GetValueAsData() and ValueObjectChild

      // not to read past the end of a host buffer, but this gets impractically

      // complicated as a Value's host buffer may be shared with a distant

      // ancestor or sibling in the ValueObject hierarchy.

      //

      // FIXME: When we grow m_value, we should represent the added bits as

      // undefined somehow instead of as 0's.

      if (value_type == Value::ValueType::HostAddress &&

          
compiler_type.IsValid()12
) {

        if (size_t value_buf_size = m_value.GetBuffer().GetByteSize()) {

          size_t value_size = m_value.GetValueByteSize(&m_error, &exe_ctx);

          if (m_error.Success() && value_buf_size < value_size)

            m_value.ResizeData(value_size);

        }

      }

      Process *process = exe_ctx.GetProcessPtr();

      const bool process_is_alive = process && 
process->IsAlive()13.0k
;

      switch (value_type) {

      case Value::ValueType::Invalid:

        m_error.SetErrorString("invalid value");

        break;

      case Value::ValueType::Scalar:

        // The variable value is in the Scalar value inside the m_value. We can

        // point our m_data right to it.

        m_error =

            m_value.GetValueAsData(&exe_ctx, m_data, GetModule().get());

        break;

      case Value::ValueType::FileAddress:

      case Value::ValueType::LoadAddress:

      case Value::ValueType::HostAddress:

        // The DWARF expression result was an address in the inferior process.

        // If this variable is an aggregate type, we just need the address as

        // the main value as all child variable objects will rely upon this

        // location and add an offset and then read their own values as needed.

        // If this variable is a simple type, we read all data for it into

        // m_data. Make sure this type has a value before we try and read it

        // If we have a file address, convert it to a load address if we can.

        if (value_type == Value::ValueType::FileAddress && 
process_is_alive1.26k
)

          m_value.ConvertToLoadAddress(GetModule().get(), target);

        if (!CanProvideValue()) {

          // this value object represents an aggregate type whose children have

          // values, but this object does not. So we say we are changed if our

          // location has changed.

          SetValueDidChange(value_type != old_value.GetValueType() ||

                            
m_value.GetScalar() != old_value.GetScalar()35
);

        } else {

          // Copy the Value and set the context to use our Variable so it can

          // extract read its value into m_data appropriately

          Value value(m_value);

          value.SetContext(Value::ContextType::Variable, variable);

          m_error =

              value.GetValueAsData(&exe_ctx, m_data, GetModule().get());

          SetValueDidChange(value_type != old_value.GetValueType() ||

                            
m_value.GetScalar() != old_value.GetScalar()287
);

        }

        break;

      }

      SetValueIsValid(m_error.Success());

    } else {

      // could not find location, won't allow editing

      m_resolved_value.SetContext(Value::ContextType::Invalid, nullptr);

    }

  }

  return m_error.Success();

}

void ValueObjectVariable::DoUpdateChildrenAddressType(ValueObject &valobj) {

  Value::ValueType value_type = valobj.GetValue().GetValueType();

  ExecutionContext exe_ctx(GetExecutionContextRef());

  Process *process = exe_ctx.GetProcessPtr();

  const bool process_is_alive = process && 
process->IsAlive()48.7k
;

  const uint32_t type_info = valobj.GetCompilerType().GetTypeInfo();

  const bool is_pointer_or_ref =

      (type_info & (lldb::eTypeIsPointer | lldb::eTypeIsReference)) != 0;

  switch (value_type) {

  case Value::ValueType::Invalid:

    break;

  case Value::ValueType::FileAddress:

    // If this type is a pointer, then its children will be considered load

    // addresses if the pointer or reference is dereferenced, but only if

    // the process is alive.

    //

    // There could be global variables like in the following code:

    // struct LinkedListNode { Foo* foo; LinkedListNode* next; };

    // Foo g_foo1;

    // Foo g_foo2;

    // LinkedListNode g_second_node = { &g_foo2, NULL };

    // LinkedListNode g_first_node = { &g_foo1, &g_second_node };

    //

    // When we aren't running, we should be able to look at these variables

    // using the "target variable" command. Children of the "g_first_node"

    // always will be of the same address type as the parent. But children

    // of the "next" member of LinkedListNode will become load addresses if

    // we have a live process, or remain a file address if it was a file

    // address.

    if (process_is_alive && 
is_pointer_or_ref0
)

      valobj.SetAddressTypeOfChildren(eAddressTypeLoad);

    else

      valobj.SetAddressTypeOfChildren(eAddressTypeFile);

    break;

  case Value::ValueType::HostAddress:

    // Same as above for load addresses, except children of pointer or refs

    // are always load addresses. Host addresses are used to store freeze

    // dried variables. If this type is a struct, the entire struct

    // contents will be copied into the heap of the

    // LLDB process, but we do not currently follow any pointers.

    if (is_pointer_or_ref)

      valobj.SetAddressTypeOfChildren(eAddressTypeLoad);

    else

      valobj.SetAddressTypeOfChildren(eAddressTypeHost);

    break;

  case Value::ValueType::LoadAddress:

  case Value::ValueType::Scalar:

    valobj.SetAddressTypeOfChildren(eAddressTypeLoad);

    break;

  }

}

bool ValueObjectVariable::IsInScope() {

  const ExecutionContextRef &exe_ctx_ref = GetExecutionContextRef();

  if (exe_ctx_ref.HasFrameRef()) {

    ExecutionContext exe_ctx(exe_ctx_ref);

    StackFrame *frame = exe_ctx.GetFramePtr();

    if (frame) {

      return m_variable_sp->IsInScope(frame);

    } else {

      // This ValueObject had a frame at one time, but now we can't locate it,

      // so return false since we probably aren't in scope.

      return false;

    }

  }

  // We have a variable that wasn't tied to a frame, which means it is a global

  // and is always in scope.

  return true;

}

lldb::ModuleSP ValueObjectVariable::GetModule() {

  if (m_variable_sp) {

    SymbolContextScope *sc_scope = m_variable_sp->GetSymbolContextScope();

    if (sc_scope) {

      return sc_scope->CalculateSymbolContextModule();

    }

  }

  return lldb::ModuleSP();

}

SymbolContextScope *ValueObjectVariable::GetSymbolContextScope() {

  if (m_variable_sp)

    return m_variable_sp->GetSymbolContextScope();

  return nullptr;

}

bool ValueObjectVariable::GetDeclaration(Declaration &decl) {

  if (m_variable_sp) {

    decl = m_variable_sp->GetDeclaration();

    return true;

  }

  return false;

}

const char *ValueObjectVariable::GetLocationAsCString() {

  if (m_resolved_value.GetContextType() == Value::ContextType::RegisterInfo)

    return GetLocationAsCStringImpl(m_resolved_value, m_data);

  else

    return ValueObject::GetLocationAsCString();

}

bool ValueObjectVariable::SetValueFromCString(const char *value_str,

                                              Status &error) {

  if (!UpdateValueIfNeeded()) {

    error.SetErrorString("unable to update value before writing");

    return false;

  }

  if (m_resolved_value.GetContextType() == Value::ContextType::RegisterInfo) {

    RegisterInfo *reg_info = m_resolved_value.GetRegisterInfo();

    ExecutionContext exe_ctx(GetExecutionContextRef());

    RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();

    RegisterValue reg_value;

    if (!reg_info || !reg_ctx) {

      error.SetErrorString("unable to retrieve register info");

      return false;

    }

    error = reg_value.SetValueFromString(reg_info, llvm::StringRef(value_str));

    if (error.Fail())

      return false;

    if (reg_ctx->WriteRegister(reg_info, reg_value)) {

      SetNeedsUpdate();

      return true;

    } else {

      error.SetErrorString("unable to write back to register");

      return false;

    }

  } else

    return ValueObject::SetValueFromCString(value_str, error);

}

bool ValueObjectVariable::SetData(DataExtractor &data, Status &error) {

  if (!UpdateValueIfNeeded()) {

    error.SetErrorString("unable to update value before writing");

    return false;

  }

  if (m_resolved_value.GetContextType() == Value::ContextType::RegisterInfo) {

    RegisterInfo *reg_info = m_resolved_value.GetRegisterInfo();

    ExecutionContext exe_ctx(GetExecutionContextRef());

    RegisterContext *reg_ctx = exe_ctx.GetRegisterContext();

    RegisterValue reg_value;

    if (!reg_info || !reg_ctx) {

      error.SetErrorString("unable to retrieve register info");

      return false;

    }

    error = reg_value.SetValueFromData(*reg_info, data, 0, true);

    if (error.Fail())

      return false;

    if (reg_ctx->WriteRegister(reg_info, reg_value)) {

      SetNeedsUpdate();

      return true;

    } else {

      error.SetErrorString("unable to write back to register");

      return false;

    }

  } else

    return ValueObject::SetData(data, error);

}