mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-29 16:29:00 -04:00
b9c1b51e45
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
299 lines
11 KiB
C++
299 lines
11 KiB
C++
//===-- ValueObjectConstResult.cpp ------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Core/ValueObjectConstResult.h"
|
|
|
|
#include "lldb/Core/DataExtractor.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/ValueObjectChild.h"
|
|
#include "lldb/Core/ValueObjectConstResultChild.h"
|
|
#include "lldb/Core/ValueObjectDynamicValue.h"
|
|
#include "lldb/Core/ValueObjectList.h"
|
|
|
|
#include "lldb/Symbol/CompilerType.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
#include "lldb/Symbol/SymbolContext.h"
|
|
#include "lldb/Symbol/Type.h"
|
|
#include "lldb/Symbol/Variable.h"
|
|
|
|
#include "lldb/Target/ExecutionContext.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/Target.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
|
|
ByteOrder byte_order,
|
|
uint32_t addr_byte_size,
|
|
lldb::addr_t address) {
|
|
return (new ValueObjectConstResult(exe_scope, byte_order, addr_byte_size,
|
|
address))
|
|
->GetSP();
|
|
}
|
|
|
|
ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
|
|
ByteOrder byte_order,
|
|
uint32_t addr_byte_size,
|
|
lldb::addr_t address)
|
|
: ValueObject(exe_scope), m_type_name(), m_byte_size(0),
|
|
m_impl(this, address) {
|
|
SetIsConstant();
|
|
SetValueIsValid(true);
|
|
m_data.SetByteOrder(byte_order);
|
|
m_data.SetAddressByteSize(addr_byte_size);
|
|
SetAddressTypeOfChildren(eAddressTypeLoad);
|
|
}
|
|
|
|
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
|
|
const CompilerType &compiler_type,
|
|
const ConstString &name,
|
|
const DataExtractor &data,
|
|
lldb::addr_t address) {
|
|
return (new ValueObjectConstResult(exe_scope, compiler_type, name, data,
|
|
address))
|
|
->GetSP();
|
|
}
|
|
|
|
ValueObjectConstResult::ValueObjectConstResult(
|
|
ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
|
|
const ConstString &name, const DataExtractor &data, lldb::addr_t address)
|
|
: ValueObject(exe_scope), m_type_name(), m_byte_size(0),
|
|
m_impl(this, address) {
|
|
m_data = data;
|
|
|
|
if (!m_data.GetSharedDataBuffer()) {
|
|
DataBufferSP shared_data_buffer(
|
|
new DataBufferHeap(data.GetDataStart(), data.GetByteSize()));
|
|
m_data.SetData(shared_data_buffer);
|
|
}
|
|
|
|
m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
|
|
m_value.SetValueType(Value::eValueTypeHostAddress);
|
|
m_value.SetCompilerType(compiler_type);
|
|
m_name = name;
|
|
SetIsConstant();
|
|
SetValueIsValid(true);
|
|
SetAddressTypeOfChildren(eAddressTypeLoad);
|
|
}
|
|
|
|
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
|
|
const CompilerType &compiler_type,
|
|
const ConstString &name,
|
|
const lldb::DataBufferSP &data_sp,
|
|
lldb::ByteOrder data_byte_order,
|
|
uint32_t data_addr_size,
|
|
lldb::addr_t address) {
|
|
return (new ValueObjectConstResult(exe_scope, compiler_type, name, data_sp,
|
|
data_byte_order, data_addr_size, address))
|
|
->GetSP();
|
|
}
|
|
|
|
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
|
|
Value &value,
|
|
const ConstString &name,
|
|
Module *module) {
|
|
return (new ValueObjectConstResult(exe_scope, value, name, module))->GetSP();
|
|
}
|
|
|
|
ValueObjectConstResult::ValueObjectConstResult(
|
|
ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
|
|
const ConstString &name, const lldb::DataBufferSP &data_sp,
|
|
lldb::ByteOrder data_byte_order, uint32_t data_addr_size,
|
|
lldb::addr_t address)
|
|
: ValueObject(exe_scope), m_type_name(), m_byte_size(0),
|
|
m_impl(this, address) {
|
|
m_data.SetByteOrder(data_byte_order);
|
|
m_data.SetAddressByteSize(data_addr_size);
|
|
m_data.SetData(data_sp);
|
|
m_value.GetScalar() = (uintptr_t)data_sp->GetBytes();
|
|
m_value.SetValueType(Value::eValueTypeHostAddress);
|
|
// m_value.SetContext(Value::eContextTypeClangType, compiler_type);
|
|
m_value.SetCompilerType(compiler_type);
|
|
m_name = name;
|
|
SetIsConstant();
|
|
SetValueIsValid(true);
|
|
SetAddressTypeOfChildren(eAddressTypeLoad);
|
|
}
|
|
|
|
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
|
|
const CompilerType &compiler_type,
|
|
const ConstString &name,
|
|
lldb::addr_t address,
|
|
AddressType address_type,
|
|
uint32_t addr_byte_size) {
|
|
return (new ValueObjectConstResult(exe_scope, compiler_type, name, address,
|
|
address_type, addr_byte_size))
|
|
->GetSP();
|
|
}
|
|
|
|
ValueObjectConstResult::ValueObjectConstResult(
|
|
ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
|
|
const ConstString &name, lldb::addr_t address, AddressType address_type,
|
|
uint32_t addr_byte_size)
|
|
: ValueObject(exe_scope), m_type_name(), m_byte_size(0),
|
|
m_impl(this, address) {
|
|
m_value.GetScalar() = address;
|
|
m_data.SetAddressByteSize(addr_byte_size);
|
|
m_value.GetScalar().GetData(m_data, addr_byte_size);
|
|
// m_value.SetValueType(Value::eValueTypeHostAddress);
|
|
switch (address_type) {
|
|
case eAddressTypeInvalid:
|
|
m_value.SetValueType(Value::eValueTypeScalar);
|
|
break;
|
|
case eAddressTypeFile:
|
|
m_value.SetValueType(Value::eValueTypeFileAddress);
|
|
break;
|
|
case eAddressTypeLoad:
|
|
m_value.SetValueType(Value::eValueTypeLoadAddress);
|
|
break;
|
|
case eAddressTypeHost:
|
|
m_value.SetValueType(Value::eValueTypeHostAddress);
|
|
break;
|
|
}
|
|
// m_value.SetContext(Value::eContextTypeClangType, compiler_type);
|
|
m_value.SetCompilerType(compiler_type);
|
|
m_name = name;
|
|
SetIsConstant();
|
|
SetValueIsValid(true);
|
|
SetAddressTypeOfChildren(eAddressTypeLoad);
|
|
}
|
|
|
|
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
|
|
const Error &error) {
|
|
return (new ValueObjectConstResult(exe_scope, error))->GetSP();
|
|
}
|
|
|
|
ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
|
|
const Error &error)
|
|
: ValueObject(exe_scope), m_type_name(), m_byte_size(0), m_impl(this) {
|
|
m_error = error;
|
|
SetIsConstant();
|
|
}
|
|
|
|
ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
|
|
const Value &value,
|
|
const ConstString &name,
|
|
Module *module)
|
|
: ValueObject(exe_scope), m_type_name(), m_byte_size(0), m_impl(this) {
|
|
m_value = value;
|
|
m_name = name;
|
|
ExecutionContext exe_ctx;
|
|
exe_scope->CalculateExecutionContext(exe_ctx);
|
|
m_error = m_value.GetValueAsData(&exe_ctx, m_data, 0, module);
|
|
}
|
|
|
|
ValueObjectConstResult::~ValueObjectConstResult() {}
|
|
|
|
CompilerType ValueObjectConstResult::GetCompilerTypeImpl() {
|
|
return m_value.GetCompilerType();
|
|
}
|
|
|
|
lldb::ValueType ValueObjectConstResult::GetValueType() const {
|
|
return eValueTypeConstResult;
|
|
}
|
|
|
|
uint64_t ValueObjectConstResult::GetByteSize() {
|
|
ExecutionContext exe_ctx(GetExecutionContextRef());
|
|
|
|
if (m_byte_size == 0)
|
|
SetByteSize(
|
|
GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope()));
|
|
return m_byte_size;
|
|
}
|
|
|
|
void ValueObjectConstResult::SetByteSize(size_t size) { m_byte_size = size; }
|
|
|
|
size_t ValueObjectConstResult::CalculateNumChildren(uint32_t max) {
|
|
auto children_count = GetCompilerType().GetNumChildren(true);
|
|
return children_count <= max ? children_count : max;
|
|
}
|
|
|
|
ConstString ValueObjectConstResult::GetTypeName() {
|
|
if (m_type_name.IsEmpty())
|
|
m_type_name = GetCompilerType().GetConstTypeName();
|
|
return m_type_name;
|
|
}
|
|
|
|
ConstString ValueObjectConstResult::GetDisplayTypeName() {
|
|
return GetCompilerType().GetDisplayTypeName();
|
|
}
|
|
|
|
bool ValueObjectConstResult::UpdateValue() {
|
|
// Const value is always valid
|
|
SetValueIsValid(true);
|
|
return true;
|
|
}
|
|
|
|
bool ValueObjectConstResult::IsInScope() {
|
|
// A const result value is always in scope since it serializes all
|
|
// information needed to contain the constant value.
|
|
return true;
|
|
}
|
|
|
|
lldb::ValueObjectSP ValueObjectConstResult::Dereference(Error &error) {
|
|
return m_impl.Dereference(error);
|
|
}
|
|
|
|
lldb::ValueObjectSP ValueObjectConstResult::GetSyntheticChildAtOffset(
|
|
uint32_t offset, const CompilerType &type, bool can_create,
|
|
ConstString name_const_str) {
|
|
return m_impl.GetSyntheticChildAtOffset(offset, type, can_create,
|
|
name_const_str);
|
|
}
|
|
|
|
lldb::ValueObjectSP ValueObjectConstResult::AddressOf(Error &error) {
|
|
return m_impl.AddressOf(error);
|
|
}
|
|
|
|
lldb::addr_t ValueObjectConstResult::GetAddressOf(bool scalar_is_load_address,
|
|
AddressType *address_type) {
|
|
return m_impl.GetAddressOf(scalar_is_load_address, address_type);
|
|
}
|
|
|
|
ValueObject *ValueObjectConstResult::CreateChildAtIndex(
|
|
size_t idx, bool synthetic_array_member, int32_t synthetic_index) {
|
|
return m_impl.CreateChildAtIndex(idx, synthetic_array_member,
|
|
synthetic_index);
|
|
}
|
|
|
|
size_t ValueObjectConstResult::GetPointeeData(DataExtractor &data,
|
|
uint32_t item_idx,
|
|
uint32_t item_count) {
|
|
return m_impl.GetPointeeData(data, item_idx, item_count);
|
|
}
|
|
|
|
lldb::ValueObjectSP
|
|
ValueObjectConstResult::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
|
|
// Always recalculate dynamic values for const results as the memory that
|
|
// they might point to might have changed at any time.
|
|
if (use_dynamic != eNoDynamicValues) {
|
|
if (!IsDynamic()) {
|
|
ExecutionContext exe_ctx(GetExecutionContextRef());
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
if (process && process->IsPossibleDynamicValue(*this))
|
|
m_dynamic_value = new ValueObjectDynamicValue(*this, use_dynamic);
|
|
}
|
|
if (m_dynamic_value)
|
|
return m_dynamic_value->GetSP();
|
|
}
|
|
return ValueObjectSP();
|
|
}
|
|
|
|
lldb::ValueObjectSP
|
|
ValueObjectConstResult::Cast(const CompilerType &compiler_type) {
|
|
return m_impl.Cast(compiler_type);
|
|
}
|
|
|
|
lldb::LanguageType ValueObjectConstResult::GetPreferredDisplayLanguage() {
|
|
if (m_preferred_display_language != lldb::eLanguageTypeUnknown)
|
|
return m_preferred_display_language;
|
|
return GetCompilerTypeImpl().GetMinimumLanguage();
|
|
}
|