SBType.cpp | Explore in Territory

//===-- SBType.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/API/SBType.h"
#include "Utils.h"
#include "lldb/API/SBDefines.h"
#include "lldb/API/SBModule.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTypeEnumMember.h"
#include "lldb/Core/Mangled.h"
#include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Symbol/CompilerDecl.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Scalar.h"
#include "lldb/Utility/Stream.h"

#include "llvm/ADT/APSInt.h"
#include "llvm/Support/MathExtras.h"

#include <memory>
#include <optional>

usingnamespacelldb;
usingnamespacelldb_private;

SBType::SBType() { … }

SBType::SBType(const CompilerType &type) : … { … }

SBType::SBType(const lldb::TypeSP &type_sp)
    : … { … }

SBType::SBType(const lldb::TypeImplSP &type_impl_sp)
    : … { … }

SBType::SBType(const SBType &rhs) { … }

// SBType::SBType (TypeImpl* impl) :
//    m_opaque_up(impl)
//{}
//
bool SBType::operator==(SBType &rhs) { … }

bool SBType::operator!=(SBType &rhs) { … }

lldb::TypeImplSP SBType::GetSP() { … }

void SBType::SetSP(const lldb::TypeImplSP &type_impl_sp) { … }

SBType &SBType::operator=(const SBType &rhs) { … }

SBType::~SBType() = default;

TypeImpl &SBType::ref() { … }

const TypeImpl &SBType::ref() const { … }

bool SBType::IsValid() const { … }
operator bool()

uint64_t SBType::GetByteSize() { … }

uint64_t SBType::GetByteAlign() { … }

bool SBType::IsPointerType() { … }

bool SBType::IsArrayType() { … }

bool SBType::IsVectorType() { … }

bool SBType::IsReferenceType() { … }

SBType SBType::GetPointerType() { … }

SBType SBType::GetPointeeType() { … }

SBType SBType::GetReferenceType() { … }

SBType SBType::GetTypedefedType() { … }

SBType SBType::GetDereferencedType() { … }

SBType SBType::GetArrayElementType() { … }

SBType SBType::GetArrayType(uint64_t size) { … }

SBType SBType::GetVectorElementType() { … }

bool SBType::IsFunctionType() { … }

bool SBType::IsPolymorphicClass() { … }

bool SBType::IsTypedefType() { … }

bool SBType::IsAnonymousType() { … }

bool SBType::IsScopedEnumerationType() { … }

bool SBType::IsAggregateType() { … }

lldb::SBType SBType::GetFunctionReturnType() { … }

lldb::SBTypeList SBType::GetFunctionArgumentTypes() { … }

uint32_t SBType::GetNumberOfMemberFunctions() { … }

lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) { … }

SBTypeStaticField::SBTypeStaticField() { … }

SBTypeStaticField::SBTypeStaticField(lldb_private::CompilerDecl decl)
    : … { … }

SBTypeStaticField::SBTypeStaticField(const SBTypeStaticField &rhs) { … }

SBTypeStaticField &SBTypeStaticField::operator=(const SBTypeStaticField &rhs) { … }

SBTypeStaticField::~SBTypeStaticField() { … }

operator bool()

bool SBTypeStaticField::IsValid() const { … }

const char *SBTypeStaticField::GetName() { … }

const char *SBTypeStaticField::GetMangledName() { … }

SBType SBTypeStaticField::GetType() { … }

SBValue SBTypeStaticField::GetConstantValue(lldb::SBTarget target) { … }

lldb::SBType SBType::GetUnqualifiedType() { … }

lldb::SBType SBType::GetCanonicalType() { … }

SBType SBType::GetEnumerationIntegerType() { … }

lldb::BasicType SBType::GetBasicType() { … }

SBType SBType::GetBasicType(lldb::BasicType basic_type) { … }

uint32_t SBType::GetNumberOfDirectBaseClasses() { … }

uint32_t SBType::GetNumberOfVirtualBaseClasses() { … }

uint32_t SBType::GetNumberOfFields() { … }

bool SBType::GetDescription(SBStream &description,
                            lldb::DescriptionLevel description_level) { … }

SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) { … }

SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) { … }

SBTypeStaticField SBType::GetStaticFieldWithName(const char *name) { … }

SBTypeEnumMemberList SBType::GetEnumMembers() { … }

SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) { … }

bool SBType::IsTypeComplete() { … }

uint32_t SBType::GetTypeFlags() { … }

lldb::SBModule SBType::GetModule() { … }

const char *SBType::GetName() { … }

const char *SBType::GetDisplayTypeName() { … }

lldb::TypeClass SBType::GetTypeClass() { … }

uint32_t SBType::GetNumberOfTemplateArguments() { … }

lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) { … }

lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) { … }

SBType SBType::FindDirectNestedType(const char *name) { … }

SBTypeList::SBTypeList() : … { … }

SBTypeList::SBTypeList(const SBTypeList &rhs)
    : … { … }

bool SBTypeList::IsValid() { … }
operator bool()

SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) { … }

void SBTypeList::Append(SBType type) { … }

SBType SBTypeList::GetTypeAtIndex(uint32_t index) { … }

uint32_t SBTypeList::GetSize() { … }

SBTypeList::~SBTypeList() = default;

SBTypeMember::SBTypeMember() { … }

SBTypeMember::~SBTypeMember() = default;

SBTypeMember::SBTypeMember(const SBTypeMember &rhs) { … }

lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) { … }

bool SBTypeMember::IsValid() const { … }
operator bool()

const char *SBTypeMember::GetName() { … }

SBType SBTypeMember::GetType() { … }

uint64_t SBTypeMember::GetOffsetInBytes() { … }

uint64_t SBTypeMember::GetOffsetInBits() { … }

bool SBTypeMember::IsBitfield() { … }

uint32_t SBTypeMember::GetBitfieldSizeInBits() { … }

bool SBTypeMember::GetDescription(lldb::SBStream &description,
                                  lldb::DescriptionLevel description_level) { … }

void SBTypeMember::reset(TypeMemberImpl *type_member_impl) { … }

TypeMemberImpl &SBTypeMember::ref() { … }

const TypeMemberImpl &SBTypeMember::ref() const { … }

SBTypeMemberFunction::SBTypeMemberFunction() { … }

SBTypeMemberFunction::~SBTypeMemberFunction() = default;

SBTypeMemberFunction::SBTypeMemberFunction(const SBTypeMemberFunction &rhs)
    : … { … }

lldb::SBTypeMemberFunction &SBTypeMemberFunction::
operator=(const lldb::SBTypeMemberFunction &rhs) { … }

bool SBTypeMemberFunction::IsValid() const { … }
operator bool()

const char *SBTypeMemberFunction::GetName() { … }

const char *SBTypeMemberFunction::GetDemangledName() { … }

const char *SBTypeMemberFunction::GetMangledName() { … }

SBType SBTypeMemberFunction::GetType() { … }

lldb::SBType SBTypeMemberFunction::GetReturnType() { … }

uint32_t SBTypeMemberFunction::GetNumberOfArguments() { … }

lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) { … }

lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() { … }

bool SBTypeMemberFunction::GetDescription(
    lldb::SBStream &description, lldb::DescriptionLevel description_level) { … }

void SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl) { … }

TypeMemberFunctionImpl &SBTypeMemberFunction::ref() { … }

const TypeMemberFunctionImpl &SBTypeMemberFunction::ref() const { … }
llvm/lldb/source/API/SBType.cpp
