Type.cpp | Explore in Territory

//===-- Type.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 <algorithm>
#include <cstdio>
#include <iterator>
#include <optional>

#include "lldb/Core/Module.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Scalar.h"
#include "lldb/Utility/StreamString.h"

#include "lldb/Symbol/CompilerType.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolContextScope.h"
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/TypeSystem.h"

#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-private-enumerations.h"

#include "llvm/ADT/StringRef.h"

usingnamespacelldb;
usingnamespacelldb_private;

llvm::raw_ostream &lldb_private::operator<<(llvm::raw_ostream &os,
                                            const CompilerContext &rhs) { … }

static CompilerContextKind ConvertTypeClass(lldb::TypeClass type_class) { … }

TypeQuery::TypeQuery(llvm::StringRef name, TypeQueryOptions options)
    : … { … }

TypeQuery::TypeQuery(const CompilerDeclContext &decl_ctx,
                     ConstString type_basename, TypeQueryOptions options)
    : … { … }

TypeQuery::TypeQuery(
    const llvm::ArrayRef<lldb_private::CompilerContext> &context,
    TypeQueryOptions options)
    : … { … }

TypeQuery::TypeQuery(const CompilerDecl &decl, TypeQueryOptions options)
    : … { … }

ConstString TypeQuery::GetTypeBasename() const { … }

void TypeQuery::AddLanguage(LanguageType language) { … }

void TypeQuery::SetLanguages(LanguageSet languages) { … }

bool TypeQuery::ContextMatches(
    llvm::ArrayRef<CompilerContext> context_chain) const { … }

bool TypeQuery::LanguageMatches(lldb::LanguageType language) const { … }

bool TypeResults::AlreadySearched(lldb_private::SymbolFile *sym_file) { … }

bool TypeResults::InsertUnique(const lldb::TypeSP &type_sp) { … }

bool TypeResults::Done(const TypeQuery &query) const { … }

void CompilerContext::Dump(Stream &s) const { … }

class TypeAppendVisitor { … };

void TypeListImpl::Append(const lldb_private::TypeList &type_list) { … }

SymbolFileType::SymbolFileType(SymbolFile &symbol_file,
                               const lldb::TypeSP &type_sp)
    : … { … }

Type *SymbolFileType::GetType() { … }

Type::Type(lldb::user_id_t uid, SymbolFile *symbol_file, ConstString name,
           std::optional<uint64_t> byte_size, SymbolContextScope *context,
           user_id_t encoding_uid, EncodingDataType encoding_uid_type,
           const Declaration &decl, const CompilerType &compiler_type,
           ResolveState compiler_type_resolve_state, uint32_t opaque_payload)
    : … { … }

Type::Type()
    : … { … }

void Type::GetDescription(Stream *s, lldb::DescriptionLevel level,
                          bool show_name, ExecutionContextScope *exe_scope) { … }

void Type::Dump(Stream *s, bool show_context, lldb::DescriptionLevel level) { … }

ConstString Type::GetName() { … }

ConstString Type::GetBaseName() { … }

void Type::DumpTypeName(Stream *s) { … }

Type *Type::GetEncodingType() { … }

std::optional<uint64_t> Type::GetByteSize(ExecutionContextScope *exe_scope) { … }

llvm::Expected<uint32_t> Type::GetNumChildren(bool omit_empty_base_classes) { … }

bool Type::IsAggregateType() { … }

bool Type::IsTemplateType() { … }

lldb::TypeSP Type::GetTypedefType() { … }

lldb::Format Type::GetFormat() { … }

lldb::Encoding Type::GetEncoding(uint64_t &count) { … }

bool Type::ReadFromMemory(ExecutionContext *exe_ctx, lldb::addr_t addr,
                          AddressType address_type, DataExtractor &data) { … }

bool Type::WriteToMemory(ExecutionContext *exe_ctx, lldb::addr_t addr,
                         AddressType address_type, DataExtractor &data) { … }

const Declaration &Type::GetDeclaration() const { … }

bool Type::ResolveCompilerType(ResolveState compiler_type_resolve_state) { … }
uint32_t Type::GetEncodingMask() { … }

CompilerType Type::GetFullCompilerType() { … }

CompilerType Type::GetLayoutCompilerType() { … }

CompilerType Type::GetForwardCompilerType() { … }

ConstString Type::GetQualifiedName() { … }

std::optional<Type::ParsedName>
Type::GetTypeScopeAndBasename(llvm::StringRef name) { … }

ModuleSP Type::GetModule() { … }

ModuleSP Type::GetExeModule() { … }

TypeAndOrName::TypeAndOrName(TypeSP &in_type_sp) { … }

TypeAndOrName::TypeAndOrName(const char *in_type_str)
    : … { … }

TypeAndOrName::TypeAndOrName(ConstString &in_type_const_string)
    : … { … }

bool TypeAndOrName::operator==(const TypeAndOrName &other) const { … }

bool TypeAndOrName::operator!=(const TypeAndOrName &other) const { … }

ConstString TypeAndOrName::GetName() const { … }

void TypeAndOrName::SetName(ConstString type_name) { … }

void TypeAndOrName::SetName(const char *type_name_cstr) { … }

void TypeAndOrName::SetName(llvm::StringRef type_name) { … }

void TypeAndOrName::SetTypeSP(lldb::TypeSP type_sp) { … }

void TypeAndOrName::SetCompilerType(CompilerType compiler_type) { … }

bool TypeAndOrName::IsEmpty() const { … }

void TypeAndOrName::Clear() { … }

bool TypeAndOrName::HasName() const { … }

bool TypeAndOrName::HasCompilerType() const { … }

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

TypeImpl::TypeImpl(const CompilerType &compiler_type)
    : … { … }

TypeImpl::TypeImpl(const lldb::TypeSP &type_sp, const CompilerType &dynamic)
    : … { … }

TypeImpl::TypeImpl(const CompilerType &static_type,
                   const CompilerType &dynamic_type)
    : … { … }

void TypeImpl::SetType(const lldb::TypeSP &type_sp) { … }

void TypeImpl::SetType(const CompilerType &compiler_type) { … }

void TypeImpl::SetType(const lldb::TypeSP &type_sp,
                       const CompilerType &dynamic) { … }

void TypeImpl::SetType(const CompilerType &compiler_type,
                       const CompilerType &dynamic) { … }

bool TypeImpl::CheckModule(lldb::ModuleSP &module_sp) const { … }

bool TypeImpl::CheckExeModule(lldb::ModuleSP &module_sp) const { … }

bool TypeImpl::CheckModuleCommon(const lldb::ModuleWP &input_module_wp,
                                 lldb::ModuleSP &module_sp) const { … }

bool TypeImpl::operator==(const TypeImpl &rhs) const { … }

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

bool TypeImpl::IsValid() const { … }

operator bool()

void TypeImpl::Clear() { … }

ModuleSP TypeImpl::GetModule() const { … }

ConstString TypeImpl::GetName() const { … }

ConstString TypeImpl::GetDisplayTypeName() const { … }

TypeImpl TypeImpl::GetPointerType() const { … }

TypeImpl TypeImpl::GetPointeeType() const { … }

TypeImpl TypeImpl::GetReferenceType() const { … }

TypeImpl TypeImpl::GetTypedefedType() const { … }

TypeImpl TypeImpl::GetDereferencedType() const { … }

TypeImpl TypeImpl::GetUnqualifiedType() const { … }

TypeImpl TypeImpl::GetCanonicalType() const { … }

CompilerType TypeImpl::GetCompilerType(bool prefer_dynamic) { … }

CompilerType::TypeSystemSPWrapper TypeImpl::GetTypeSystem(bool prefer_dynamic) { … }

bool TypeImpl::GetDescription(lldb_private::Stream &strm,
                              lldb::DescriptionLevel description_level) { … }

CompilerType TypeImpl::FindDirectNestedType(llvm::StringRef name) { … }

bool TypeMemberFunctionImpl::IsValid() { … }

ConstString TypeMemberFunctionImpl::GetName() const { … }

ConstString TypeMemberFunctionImpl::GetMangledName() const { … }

CompilerType TypeMemberFunctionImpl::GetType() const { … }

lldb::MemberFunctionKind TypeMemberFunctionImpl::GetKind() const { … }

bool TypeMemberFunctionImpl::GetDescription(Stream &stream) { … }

CompilerType TypeMemberFunctionImpl::GetReturnType() const { … }

size_t TypeMemberFunctionImpl::GetNumArguments() const { … }

CompilerType TypeMemberFunctionImpl::GetArgumentAtIndex(size_t idx) const { … }

TypeEnumMemberImpl::TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp,
                                       ConstString name,
                                       const llvm::APSInt &value)
    : … { … }
llvm/lldb/source/Symbol/Type.cpp
