mirror of
https://github.com/opnsense/src.git
synced 2026-02-27 11:50:47 -05:00
1320 lines
35 KiB
C++
1320 lines
35 KiB
C++
//===-- CompilerType.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/Symbol/CompilerType.h"
|
|
|
|
#include "lldb/Core/ConstString.h"
|
|
#include "lldb/Core/DataBufferHeap.h"
|
|
#include "lldb/Core/DataExtractor.h"
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Core/Scalar.h"
|
|
#include "lldb/Core/Stream.h"
|
|
#include "lldb/Core/StreamFile.h"
|
|
#include "lldb/Core/StreamString.h"
|
|
#include "lldb/Symbol/ClangASTContext.h"
|
|
#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
|
|
#include "lldb/Symbol/Type.h"
|
|
#include "lldb/Target/ExecutionContext.h"
|
|
#include "lldb/Target/Process.h"
|
|
|
|
#include <iterator>
|
|
#include <mutex>
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
CompilerType::CompilerType (TypeSystem *type_system,
|
|
lldb::opaque_compiler_type_t type) :
|
|
m_type (type),
|
|
m_type_system (type_system)
|
|
{
|
|
}
|
|
|
|
CompilerType::CompilerType (clang::ASTContext *ast,
|
|
clang::QualType qual_type) :
|
|
m_type (qual_type.getAsOpaquePtr()),
|
|
m_type_system (ClangASTContext::GetASTContext(ast))
|
|
{
|
|
#ifdef LLDB_CONFIGURATION_DEBUG
|
|
if (m_type)
|
|
assert(m_type_system != nullptr);
|
|
#endif
|
|
}
|
|
|
|
CompilerType::~CompilerType()
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Tests
|
|
//----------------------------------------------------------------------
|
|
|
|
bool
|
|
CompilerType::IsAggregateType () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsAggregateType(m_type);
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsAnonymousType () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsAnonymousType(m_type);
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsArrayType (CompilerType *element_type_ptr,
|
|
uint64_t *size,
|
|
bool *is_incomplete) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsArrayType(m_type, element_type_ptr, size, is_incomplete);
|
|
|
|
if (element_type_ptr)
|
|
element_type_ptr->Clear();
|
|
if (size)
|
|
*size = 0;
|
|
if (is_incomplete)
|
|
*is_incomplete = false;
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsVectorType (CompilerType *element_type,
|
|
uint64_t *size) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsVectorType(m_type, element_type, size);
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsRuntimeGeneratedType () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsRuntimeGeneratedType(m_type);
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsCharType () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsCharType(m_type);
|
|
return false;
|
|
}
|
|
|
|
|
|
bool
|
|
CompilerType::IsCompleteType () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsCompleteType(m_type);
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsConst() const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsConst(m_type);
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsCStringType (uint32_t &length) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsCStringType(m_type, length);
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsFunctionType (bool *is_variadic_ptr) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsFunctionType(m_type, is_variadic_ptr);
|
|
return false;
|
|
}
|
|
|
|
// Used to detect "Homogeneous Floating-point Aggregates"
|
|
uint32_t
|
|
CompilerType::IsHomogeneousAggregate (CompilerType* base_type_ptr) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsHomogeneousAggregate(m_type, base_type_ptr);
|
|
return 0;
|
|
}
|
|
|
|
size_t
|
|
CompilerType::GetNumberOfFunctionArguments () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetNumberOfFunctionArguments(m_type);
|
|
return 0;
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetFunctionArgumentAtIndex (const size_t index) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetFunctionArgumentAtIndex(m_type, index);
|
|
return CompilerType();
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsFunctionPointerType () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsFunctionPointerType(m_type);
|
|
return false;
|
|
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsIntegerType (bool &is_signed) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsIntegerType(m_type, is_signed);
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsPointerType (CompilerType *pointee_type) const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->IsPointerType(m_type, pointee_type);
|
|
}
|
|
if (pointee_type)
|
|
pointee_type->Clear();
|
|
return false;
|
|
}
|
|
|
|
|
|
bool
|
|
CompilerType::IsPointerOrReferenceType (CompilerType *pointee_type) const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->IsPointerOrReferenceType(m_type, pointee_type);
|
|
}
|
|
if (pointee_type)
|
|
pointee_type->Clear();
|
|
return false;
|
|
}
|
|
|
|
|
|
bool
|
|
CompilerType::IsReferenceType (CompilerType *pointee_type, bool* is_rvalue) const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->IsReferenceType(m_type, pointee_type, is_rvalue);
|
|
}
|
|
if (pointee_type)
|
|
pointee_type->Clear();
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::ShouldTreatScalarValueAsAddress () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->ShouldTreatScalarValueAsAddress(m_type);
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsFloatingPointType (uint32_t &count, bool &is_complex) const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->IsFloatingPointType(m_type, count, is_complex);
|
|
}
|
|
count = 0;
|
|
is_complex = false;
|
|
return false;
|
|
}
|
|
|
|
|
|
bool
|
|
CompilerType::IsDefined() const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsDefined(m_type);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsPolymorphicClass () const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->IsPolymorphicClass(m_type);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsPossibleDynamicType (CompilerType *dynamic_pointee_type,
|
|
bool check_cplusplus,
|
|
bool check_objc) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsPossibleDynamicType(m_type, dynamic_pointee_type, check_cplusplus, check_objc);
|
|
return false;
|
|
}
|
|
|
|
|
|
bool
|
|
CompilerType::IsScalarType () const
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
|
|
return m_type_system->IsScalarType(m_type);
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsTypedefType () const
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
return m_type_system->IsTypedefType(m_type);
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsVoidType () const
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
return m_type_system->IsVoidType(m_type);
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsPointerToScalarType () const
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
|
|
return IsPointerType() && GetPointeeType().IsScalarType();
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsArrayOfScalarType () const
|
|
{
|
|
CompilerType element_type;
|
|
if (IsArrayType(&element_type, nullptr, nullptr))
|
|
return element_type.IsScalarType();
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsBeingDefined () const
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
return m_type_system->IsBeingDefined(m_type);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Type Completion
|
|
//----------------------------------------------------------------------
|
|
|
|
bool
|
|
CompilerType::GetCompleteType () const
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
return m_type_system->GetCompleteType(m_type);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// AST related queries
|
|
//----------------------------------------------------------------------
|
|
size_t
|
|
CompilerType::GetPointerByteSize () const
|
|
{
|
|
if (m_type_system)
|
|
return m_type_system->GetPointerByteSize();
|
|
return 0;
|
|
}
|
|
|
|
ConstString
|
|
CompilerType::GetConstQualifiedTypeName () const
|
|
{
|
|
return GetConstTypeName ();
|
|
}
|
|
|
|
ConstString
|
|
CompilerType::GetConstTypeName () const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
ConstString type_name (GetTypeName());
|
|
if (type_name)
|
|
return type_name;
|
|
}
|
|
return ConstString("<invalid>");
|
|
}
|
|
|
|
ConstString
|
|
CompilerType::GetTypeName () const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->GetTypeName(m_type);
|
|
}
|
|
return ConstString("<invalid>");
|
|
}
|
|
|
|
ConstString
|
|
CompilerType::GetDisplayTypeName () const
|
|
{
|
|
return GetTypeName();
|
|
}
|
|
|
|
uint32_t
|
|
CompilerType::GetTypeInfo (CompilerType *pointee_or_element_compiler_type) const
|
|
{
|
|
if (!IsValid())
|
|
return 0;
|
|
|
|
return m_type_system->GetTypeInfo(m_type, pointee_or_element_compiler_type);
|
|
}
|
|
|
|
|
|
|
|
lldb::LanguageType
|
|
CompilerType::GetMinimumLanguage ()
|
|
{
|
|
if (!IsValid())
|
|
return lldb::eLanguageTypeC;
|
|
|
|
return m_type_system->GetMinimumLanguage(m_type);
|
|
}
|
|
|
|
lldb::TypeClass
|
|
CompilerType::GetTypeClass () const
|
|
{
|
|
if (!IsValid())
|
|
return lldb::eTypeClassInvalid;
|
|
|
|
return m_type_system->GetTypeClass(m_type);
|
|
|
|
}
|
|
|
|
void
|
|
CompilerType::SetCompilerType (TypeSystem* type_system, lldb::opaque_compiler_type_t type)
|
|
{
|
|
m_type_system = type_system;
|
|
m_type = type;
|
|
}
|
|
|
|
void
|
|
CompilerType::SetCompilerType (clang::ASTContext *ast, clang::QualType qual_type)
|
|
{
|
|
m_type_system = ClangASTContext::GetASTContext(ast);
|
|
m_type = qual_type.getAsOpaquePtr();
|
|
}
|
|
|
|
unsigned
|
|
CompilerType::GetTypeQualifiers() const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetTypeQualifiers(m_type);
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Creating related types
|
|
//----------------------------------------------------------------------
|
|
|
|
CompilerType
|
|
CompilerType::GetArrayElementType (uint64_t *stride) const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->GetArrayElementType(m_type, stride);
|
|
|
|
}
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetCanonicalType () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetCanonicalType(m_type);
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetFullyUnqualifiedType () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetFullyUnqualifiedType(m_type);
|
|
return CompilerType();
|
|
}
|
|
|
|
|
|
int
|
|
CompilerType::GetFunctionArgumentCount () const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->GetFunctionArgumentCount(m_type);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetFunctionArgumentTypeAtIndex (size_t idx) const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->GetFunctionArgumentTypeAtIndex(m_type, idx);
|
|
}
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetFunctionReturnType () const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->GetFunctionReturnType(m_type);
|
|
}
|
|
return CompilerType();
|
|
}
|
|
|
|
size_t
|
|
CompilerType::GetNumMemberFunctions () const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->GetNumMemberFunctions(m_type);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
TypeMemberFunctionImpl
|
|
CompilerType::GetMemberFunctionAtIndex (size_t idx)
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->GetMemberFunctionAtIndex(m_type, idx);
|
|
}
|
|
return TypeMemberFunctionImpl();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetNonReferenceType () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetNonReferenceType(m_type);
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetPointeeType () const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->GetPointeeType(m_type);
|
|
}
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetPointerType () const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->GetPointerType(m_type);
|
|
}
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetLValueReferenceType () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetLValueReferenceType(m_type);
|
|
else
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetRValueReferenceType () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetRValueReferenceType(m_type);
|
|
else
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::AddConstModifier () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->AddConstModifier(m_type);
|
|
else
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::AddVolatileModifier () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->AddVolatileModifier(m_type);
|
|
else
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::AddRestrictModifier () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->AddRestrictModifier(m_type);
|
|
else
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::CreateTypedef (const char *name, const CompilerDeclContext &decl_ctx) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->CreateTypedef(m_type, name, decl_ctx);
|
|
else
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetTypedefedType () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetTypedefedType(m_type);
|
|
else
|
|
return CompilerType();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Create related types using the current type's AST
|
|
//----------------------------------------------------------------------
|
|
|
|
CompilerType
|
|
CompilerType::GetBasicTypeFromAST (lldb::BasicType basic_type) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetBasicTypeFromAST(basic_type);
|
|
return CompilerType();
|
|
}
|
|
//----------------------------------------------------------------------
|
|
// Exploring the type
|
|
//----------------------------------------------------------------------
|
|
|
|
uint64_t
|
|
CompilerType::GetBitSize (ExecutionContextScope *exe_scope) const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->GetBitSize(m_type, exe_scope);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint64_t
|
|
CompilerType::GetByteSize (ExecutionContextScope *exe_scope) const
|
|
{
|
|
return (GetBitSize (exe_scope) + 7) / 8;
|
|
}
|
|
|
|
|
|
size_t
|
|
CompilerType::GetTypeBitAlign () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetTypeBitAlign(m_type);
|
|
return 0;
|
|
}
|
|
|
|
|
|
lldb::Encoding
|
|
CompilerType::GetEncoding (uint64_t &count) const
|
|
{
|
|
if (!IsValid())
|
|
return lldb::eEncodingInvalid;
|
|
|
|
return m_type_system->GetEncoding(m_type, count);
|
|
}
|
|
|
|
lldb::Format
|
|
CompilerType::GetFormat () const
|
|
{
|
|
if (!IsValid())
|
|
return lldb::eFormatDefault;
|
|
|
|
return m_type_system->GetFormat(m_type);
|
|
}
|
|
|
|
uint32_t
|
|
CompilerType::GetNumChildren (bool omit_empty_base_classes) const
|
|
{
|
|
if (!IsValid())
|
|
return 0;
|
|
return m_type_system->GetNumChildren(m_type, omit_empty_base_classes);
|
|
}
|
|
|
|
lldb::BasicType
|
|
CompilerType::GetBasicTypeEnumeration () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetBasicTypeEnumeration(m_type);
|
|
return eBasicTypeInvalid;
|
|
}
|
|
|
|
void
|
|
CompilerType::ForEachEnumerator (std::function <bool (const CompilerType &integer_type, const ConstString &name, const llvm::APSInt &value)> const &callback) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->ForEachEnumerator (m_type, callback);
|
|
}
|
|
|
|
|
|
uint32_t
|
|
CompilerType::GetNumFields () const
|
|
{
|
|
if (!IsValid())
|
|
return 0;
|
|
return m_type_system->GetNumFields(m_type);
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetFieldAtIndex (size_t idx,
|
|
std::string& name,
|
|
uint64_t *bit_offset_ptr,
|
|
uint32_t *bitfield_bit_size_ptr,
|
|
bool *is_bitfield_ptr) const
|
|
{
|
|
if (!IsValid())
|
|
return CompilerType();
|
|
return m_type_system->GetFieldAtIndex(m_type, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr);
|
|
}
|
|
|
|
uint32_t
|
|
CompilerType::GetNumDirectBaseClasses () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetNumDirectBaseClasses (m_type);
|
|
return 0;
|
|
}
|
|
|
|
uint32_t
|
|
CompilerType::GetNumVirtualBaseClasses () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetNumVirtualBaseClasses (m_type);
|
|
return 0;
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetDirectBaseClassAtIndex (m_type, idx, bit_offset_ptr);
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetVirtualBaseClassAtIndex (m_type, idx, bit_offset_ptr);
|
|
return CompilerType();
|
|
}
|
|
|
|
uint32_t
|
|
CompilerType::GetIndexOfFieldWithName (const char* name,
|
|
CompilerType* field_compiler_type_ptr,
|
|
uint64_t *bit_offset_ptr,
|
|
uint32_t *bitfield_bit_size_ptr,
|
|
bool *is_bitfield_ptr) const
|
|
{
|
|
unsigned count = GetNumFields();
|
|
std::string field_name;
|
|
for (unsigned index = 0; index < count; index++)
|
|
{
|
|
CompilerType field_compiler_type (GetFieldAtIndex(index, field_name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
|
|
if (strcmp(field_name.c_str(), name) == 0)
|
|
{
|
|
if (field_compiler_type_ptr)
|
|
*field_compiler_type_ptr = field_compiler_type;
|
|
return index;
|
|
}
|
|
}
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
|
|
CompilerType
|
|
CompilerType::GetChildCompilerTypeAtIndex (ExecutionContext *exe_ctx,
|
|
size_t idx,
|
|
bool transparent_pointers,
|
|
bool omit_empty_base_classes,
|
|
bool ignore_array_bounds,
|
|
std::string& child_name,
|
|
uint32_t &child_byte_size,
|
|
int32_t &child_byte_offset,
|
|
uint32_t &child_bitfield_bit_size,
|
|
uint32_t &child_bitfield_bit_offset,
|
|
bool &child_is_base_class,
|
|
bool &child_is_deref_of_parent,
|
|
ValueObject *valobj,
|
|
uint64_t &language_flags) const
|
|
{
|
|
if (!IsValid())
|
|
return CompilerType();
|
|
return m_type_system->GetChildCompilerTypeAtIndex(m_type,
|
|
exe_ctx,
|
|
idx,
|
|
transparent_pointers,
|
|
omit_empty_base_classes,
|
|
ignore_array_bounds,
|
|
child_name,
|
|
child_byte_size,
|
|
child_byte_offset,
|
|
child_bitfield_bit_size,
|
|
child_bitfield_bit_offset,
|
|
child_is_base_class,
|
|
child_is_deref_of_parent,
|
|
valobj,
|
|
language_flags);
|
|
}
|
|
|
|
// Look for a child member (doesn't include base classes, but it does include
|
|
// their members) in the type hierarchy. Returns an index path into "clang_type"
|
|
// on how to reach the appropriate member.
|
|
//
|
|
// class A
|
|
// {
|
|
// public:
|
|
// int m_a;
|
|
// int m_b;
|
|
// };
|
|
//
|
|
// class B
|
|
// {
|
|
// };
|
|
//
|
|
// class C :
|
|
// public B,
|
|
// public A
|
|
// {
|
|
// };
|
|
//
|
|
// If we have a clang type that describes "class C", and we wanted to looked
|
|
// "m_b" in it:
|
|
//
|
|
// With omit_empty_base_classes == false we would get an integer array back with:
|
|
// { 1, 1 }
|
|
// The first index 1 is the child index for "class A" within class C
|
|
// The second index 1 is the child index for "m_b" within class A
|
|
//
|
|
// With omit_empty_base_classes == true we would get an integer array back with:
|
|
// { 0, 1 }
|
|
// The first index 0 is the child index for "class A" within class C (since class B doesn't have any members it doesn't count)
|
|
// The second index 1 is the child index for "m_b" within class A
|
|
|
|
size_t
|
|
CompilerType::GetIndexOfChildMemberWithName (const char *name,
|
|
bool omit_empty_base_classes,
|
|
std::vector<uint32_t>& child_indexes) const
|
|
{
|
|
if (IsValid() && name && name[0])
|
|
{
|
|
return m_type_system->GetIndexOfChildMemberWithName(m_type, name, omit_empty_base_classes, child_indexes);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
size_t
|
|
CompilerType::GetNumTemplateArguments () const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->GetNumTemplateArguments(m_type);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetTemplateArgument (size_t idx,
|
|
lldb::TemplateArgumentKind &kind) const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
return m_type_system->GetTemplateArgument(m_type, idx, kind);
|
|
}
|
|
return CompilerType();
|
|
}
|
|
|
|
CompilerType
|
|
CompilerType::GetTypeForFormatters () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->GetTypeForFormatters(m_type);
|
|
return CompilerType();
|
|
}
|
|
|
|
LazyBool
|
|
CompilerType::ShouldPrintAsOneLiner (ValueObject* valobj) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->ShouldPrintAsOneLiner(m_type, valobj);
|
|
return eLazyBoolCalculate;
|
|
}
|
|
|
|
bool
|
|
CompilerType::IsMeaninglessWithoutDynamicResolution () const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->IsMeaninglessWithoutDynamicResolution(m_type);
|
|
return false;
|
|
}
|
|
|
|
// Get the index of the child of "clang_type" whose name matches. This function
|
|
// doesn't descend into the children, but only looks one level deep and name
|
|
// matches can include base class names.
|
|
|
|
uint32_t
|
|
CompilerType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_classes) const
|
|
{
|
|
if (IsValid() && name && name[0])
|
|
{
|
|
return m_type_system->GetIndexOfChildWithName(m_type, name, omit_empty_base_classes);
|
|
}
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
size_t
|
|
CompilerType::ConvertStringToFloatValue (const char *s, uint8_t *dst, size_t dst_size) const
|
|
{
|
|
if (IsValid())
|
|
return m_type_system->ConvertStringToFloatValue(m_type, s, dst, dst_size);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// Dumping types
|
|
//----------------------------------------------------------------------
|
|
#define DEPTH_INCREMENT 2
|
|
|
|
void
|
|
CompilerType::DumpValue (ExecutionContext *exe_ctx,
|
|
Stream *s,
|
|
lldb::Format format,
|
|
const lldb_private::DataExtractor &data,
|
|
lldb::offset_t data_byte_offset,
|
|
size_t data_byte_size,
|
|
uint32_t bitfield_bit_size,
|
|
uint32_t bitfield_bit_offset,
|
|
bool show_types,
|
|
bool show_summary,
|
|
bool verbose,
|
|
uint32_t depth)
|
|
{
|
|
if (!IsValid())
|
|
return;
|
|
m_type_system->DumpValue(m_type, exe_ctx, s, format, data, data_byte_offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset, show_types, show_summary, verbose, depth);
|
|
}
|
|
|
|
|
|
|
|
|
|
bool
|
|
CompilerType::DumpTypeValue (Stream *s,
|
|
lldb::Format format,
|
|
const lldb_private::DataExtractor &data,
|
|
lldb::offset_t byte_offset,
|
|
size_t byte_size,
|
|
uint32_t bitfield_bit_size,
|
|
uint32_t bitfield_bit_offset,
|
|
ExecutionContextScope *exe_scope)
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
return m_type_system->DumpTypeValue(m_type, s, format, data, byte_offset, byte_size, bitfield_bit_size, bitfield_bit_offset, exe_scope);
|
|
}
|
|
|
|
|
|
|
|
void
|
|
CompilerType::DumpSummary (ExecutionContext *exe_ctx,
|
|
Stream *s,
|
|
const lldb_private::DataExtractor &data,
|
|
lldb::offset_t data_byte_offset,
|
|
size_t data_byte_size)
|
|
{
|
|
if (IsValid())
|
|
m_type_system->DumpSummary(m_type, exe_ctx, s, data, data_byte_offset, data_byte_size);
|
|
}
|
|
|
|
void
|
|
CompilerType::DumpTypeDescription () const
|
|
{
|
|
if (IsValid())
|
|
m_type_system->DumpTypeDescription(m_type);
|
|
}
|
|
|
|
void
|
|
CompilerType::DumpTypeDescription (Stream *s) const
|
|
{
|
|
if (IsValid())
|
|
{
|
|
m_type_system->DumpTypeDescription(m_type, s);
|
|
}
|
|
}
|
|
|
|
bool
|
|
CompilerType::GetValueAsScalar (const lldb_private::DataExtractor &data,
|
|
lldb::offset_t data_byte_offset,
|
|
size_t data_byte_size,
|
|
Scalar &value) const
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
|
|
if (IsAggregateType ())
|
|
{
|
|
return false; // Aggregate types don't have scalar values
|
|
}
|
|
else
|
|
{
|
|
uint64_t count = 0;
|
|
lldb::Encoding encoding = GetEncoding (count);
|
|
|
|
if (encoding == lldb::eEncodingInvalid || count != 1)
|
|
return false;
|
|
|
|
const uint64_t byte_size = GetByteSize(nullptr);
|
|
lldb::offset_t offset = data_byte_offset;
|
|
switch (encoding)
|
|
{
|
|
case lldb::eEncodingInvalid:
|
|
break;
|
|
case lldb::eEncodingVector:
|
|
break;
|
|
case lldb::eEncodingUint:
|
|
if (byte_size <= sizeof(unsigned long long))
|
|
{
|
|
uint64_t uval64 = data.GetMaxU64 (&offset, byte_size);
|
|
if (byte_size <= sizeof(unsigned int))
|
|
{
|
|
value = (unsigned int)uval64;
|
|
return true;
|
|
}
|
|
else if (byte_size <= sizeof(unsigned long))
|
|
{
|
|
value = (unsigned long)uval64;
|
|
return true;
|
|
}
|
|
else if (byte_size <= sizeof(unsigned long long))
|
|
{
|
|
value = (unsigned long long )uval64;
|
|
return true;
|
|
}
|
|
else
|
|
value.Clear();
|
|
}
|
|
break;
|
|
|
|
case lldb::eEncodingSint:
|
|
if (byte_size <= sizeof(long long))
|
|
{
|
|
int64_t sval64 = data.GetMaxS64 (&offset, byte_size);
|
|
if (byte_size <= sizeof(int))
|
|
{
|
|
value = (int)sval64;
|
|
return true;
|
|
}
|
|
else if (byte_size <= sizeof(long))
|
|
{
|
|
value = (long)sval64;
|
|
return true;
|
|
}
|
|
else if (byte_size <= sizeof(long long))
|
|
{
|
|
value = (long long )sval64;
|
|
return true;
|
|
}
|
|
else
|
|
value.Clear();
|
|
}
|
|
break;
|
|
|
|
case lldb::eEncodingIEEE754:
|
|
if (byte_size <= sizeof(long double))
|
|
{
|
|
uint32_t u32;
|
|
uint64_t u64;
|
|
if (byte_size == sizeof(float))
|
|
{
|
|
if (sizeof(float) == sizeof(uint32_t))
|
|
{
|
|
u32 = data.GetU32(&offset);
|
|
value = *((float *)&u32);
|
|
return true;
|
|
}
|
|
else if (sizeof(float) == sizeof(uint64_t))
|
|
{
|
|
u64 = data.GetU64(&offset);
|
|
value = *((float *)&u64);
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
if (byte_size == sizeof(double))
|
|
{
|
|
if (sizeof(double) == sizeof(uint32_t))
|
|
{
|
|
u32 = data.GetU32(&offset);
|
|
value = *((double *)&u32);
|
|
return true;
|
|
}
|
|
else if (sizeof(double) == sizeof(uint64_t))
|
|
{
|
|
u64 = data.GetU64(&offset);
|
|
value = *((double *)&u64);
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
if (byte_size == sizeof(long double))
|
|
{
|
|
if (sizeof(long double) == sizeof(uint32_t))
|
|
{
|
|
u32 = data.GetU32(&offset);
|
|
value = *((long double *)&u32);
|
|
return true;
|
|
}
|
|
else if (sizeof(long double) == sizeof(uint64_t))
|
|
{
|
|
u64 = data.GetU64(&offset);
|
|
value = *((long double *)&u64);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::SetValueFromScalar (const Scalar &value, Stream &strm)
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
|
|
// Aggregate types don't have scalar values
|
|
if (!IsAggregateType ())
|
|
{
|
|
strm.GetFlags().Set(Stream::eBinary);
|
|
uint64_t count = 0;
|
|
lldb::Encoding encoding = GetEncoding (count);
|
|
|
|
if (encoding == lldb::eEncodingInvalid || count != 1)
|
|
return false;
|
|
|
|
const uint64_t bit_width = GetBitSize(nullptr);
|
|
// This function doesn't currently handle non-byte aligned assignments
|
|
if ((bit_width % 8) != 0)
|
|
return false;
|
|
|
|
const uint64_t byte_size = (bit_width + 7 ) / 8;
|
|
switch (encoding)
|
|
{
|
|
case lldb::eEncodingInvalid:
|
|
break;
|
|
case lldb::eEncodingVector:
|
|
break;
|
|
case lldb::eEncodingUint:
|
|
switch (byte_size)
|
|
{
|
|
case 1: strm.PutHex8(value.UInt()); return true;
|
|
case 2: strm.PutHex16(value.UInt()); return true;
|
|
case 4: strm.PutHex32(value.UInt()); return true;
|
|
case 8: strm.PutHex64(value.ULongLong()); return true;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case lldb::eEncodingSint:
|
|
switch (byte_size)
|
|
{
|
|
case 1: strm.PutHex8(value.SInt()); return true;
|
|
case 2: strm.PutHex16(value.SInt()); return true;
|
|
case 4: strm.PutHex32(value.SInt()); return true;
|
|
case 8: strm.PutHex64(value.SLongLong()); return true;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case lldb::eEncodingIEEE754:
|
|
if (byte_size <= sizeof(long double))
|
|
{
|
|
if (byte_size == sizeof(float))
|
|
{
|
|
strm.PutFloat(value.Float());
|
|
return true;
|
|
}
|
|
else
|
|
if (byte_size == sizeof(double))
|
|
{
|
|
strm.PutDouble(value.Double());
|
|
return true;
|
|
}
|
|
else
|
|
if (byte_size == sizeof(long double))
|
|
{
|
|
strm.PutDouble(value.LongDouble());
|
|
return true;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::ReadFromMemory (lldb_private::ExecutionContext *exe_ctx,
|
|
lldb::addr_t addr,
|
|
AddressType address_type,
|
|
lldb_private::DataExtractor &data)
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
|
|
// Can't convert a file address to anything valid without more
|
|
// context (which Module it came from)
|
|
if (address_type == eAddressTypeFile)
|
|
return false;
|
|
|
|
if (!GetCompleteType())
|
|
return false;
|
|
|
|
const uint64_t byte_size = GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
|
|
if (data.GetByteSize() < byte_size)
|
|
{
|
|
lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0'));
|
|
data.SetData(data_sp);
|
|
}
|
|
|
|
uint8_t* dst = const_cast<uint8_t*>(data.PeekData(0, byte_size));
|
|
if (dst != nullptr)
|
|
{
|
|
if (address_type == eAddressTypeHost)
|
|
{
|
|
if (addr == 0)
|
|
return false;
|
|
// The address is an address in this process, so just copy it
|
|
memcpy (dst, (uint8_t*)nullptr + addr, byte_size);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Process *process = nullptr;
|
|
if (exe_ctx)
|
|
process = exe_ctx->GetProcessPtr();
|
|
if (process)
|
|
{
|
|
Error error;
|
|
return process->ReadMemory(addr, dst, byte_size, error) == byte_size;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
CompilerType::WriteToMemory (lldb_private::ExecutionContext *exe_ctx,
|
|
lldb::addr_t addr,
|
|
AddressType address_type,
|
|
StreamString &new_value)
|
|
{
|
|
if (!IsValid())
|
|
return false;
|
|
|
|
// Can't convert a file address to anything valid without more
|
|
// context (which Module it came from)
|
|
if (address_type == eAddressTypeFile)
|
|
return false;
|
|
|
|
if (!GetCompleteType())
|
|
return false;
|
|
|
|
const uint64_t byte_size = GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
|
|
|
|
if (byte_size > 0)
|
|
{
|
|
if (address_type == eAddressTypeHost)
|
|
{
|
|
// The address is an address in this process, so just copy it
|
|
memcpy ((void *)addr, new_value.GetData(), byte_size);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Process *process = nullptr;
|
|
if (exe_ctx)
|
|
process = exe_ctx->GetProcessPtr();
|
|
if (process)
|
|
{
|
|
Error error;
|
|
return process->WriteMemory(addr, new_value.GetData(), byte_size, error) == byte_size;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//clang::CXXRecordDecl *
|
|
//CompilerType::GetAsCXXRecordDecl (lldb::opaque_compiler_type_t opaque_compiler_qual_type)
|
|
//{
|
|
// if (opaque_compiler_qual_type)
|
|
// return clang::QualType::getFromOpaquePtr(opaque_compiler_qual_type)->getAsCXXRecordDecl();
|
|
// return NULL;
|
|
//}
|
|
|
|
bool
|
|
lldb_private::operator == (const lldb_private::CompilerType &lhs, const lldb_private::CompilerType &rhs)
|
|
{
|
|
return lhs.GetTypeSystem() == rhs.GetTypeSystem() && lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType();
|
|
}
|
|
|
|
|
|
bool
|
|
lldb_private::operator != (const lldb_private::CompilerType &lhs, const lldb_private::CompilerType &rhs)
|
|
{
|
|
return lhs.GetTypeSystem() != rhs.GetTypeSystem() || lhs.GetOpaqueQualType() != rhs.GetOpaqueQualType();
|
|
}
|
|
|
|
|
|
|