TypeSystem.cpp | Explore in Territory

//===-- TypeSystem.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/Symbol/TypeSystem.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Expression/UtilityFunction.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/Language.h"

#include "llvm/ADT/DenseSet.h"
#include <optional>

usingnamespacelldb_private;
usingnamespacelldb;

/// A 64-bit SmallBitVector is only small up to 64-7 bits, and the
/// setBitsInMask interface wants to write full bytes.
static const size_t g_num_small_bitvector_bits = …;
static_assert …;
LanguageSet::LanguageSet() : … { … }

std::optional<LanguageType> LanguageSet::GetSingularLanguage() { … }

void LanguageSet::Insert(LanguageType language) { … }
size_t LanguageSet::Size() const { … }
bool LanguageSet::Empty() const { … }
bool LanguageSet::operator[](unsigned i) const { … }

TypeSystem::TypeSystem() = default;
TypeSystem::~TypeSystem() = default;

static TypeSystemSP CreateInstanceHelper(lldb::LanguageType language,
                                         Module *module, Target *target) { … }

lldb::TypeSystemSP TypeSystem::CreateInstance(lldb::LanguageType language,
                                              Module *module) { … }

lldb::TypeSystemSP TypeSystem::CreateInstance(lldb::LanguageType language,
                                              Target *target) { … }

#ifndef NDEBUG
bool TypeSystem::Verify(lldb::opaque_compiler_type_t type) { return true; }
#endif

bool TypeSystem::IsAnonymousType(lldb::opaque_compiler_type_t type) { … }

CompilerType TypeSystem::GetArrayType(lldb::opaque_compiler_type_t type,
                                      uint64_t size) { … }

CompilerType
TypeSystem::GetLValueReferenceType(lldb::opaque_compiler_type_t type) { … }

CompilerType
TypeSystem::GetRValueReferenceType(lldb::opaque_compiler_type_t type) { … }

CompilerType TypeSystem::GetAtomicType(lldb::opaque_compiler_type_t type) { … }

CompilerType TypeSystem::AddConstModifier(lldb::opaque_compiler_type_t type) { … }

CompilerType TypeSystem::AddPtrAuthModifier(lldb::opaque_compiler_type_t type,
                                            uint32_t payload) { … }

CompilerType
TypeSystem::AddVolatileModifier(lldb::opaque_compiler_type_t type) { … }

CompilerType
TypeSystem::AddRestrictModifier(lldb::opaque_compiler_type_t type) { … }

CompilerType TypeSystem::CreateTypedef(lldb::opaque_compiler_type_t type,
                                       const char *name,
                                       const CompilerDeclContext &decl_ctx,
                                       uint32_t opaque_payload) { … }

CompilerType TypeSystem::GetBuiltinTypeByName(ConstString name) { … }

CompilerType TypeSystem::GetTypeForFormatters(void *type) { … }

bool TypeSystem::IsTemplateType(lldb::opaque_compiler_type_t type) { … }

size_t TypeSystem::GetNumTemplateArguments(lldb::opaque_compiler_type_t type,
                                           bool expand_pack) { … }

TemplateArgumentKind
TypeSystem::GetTemplateArgumentKind(opaque_compiler_type_t type, size_t idx,
                                    bool expand_pack) { … }

CompilerType TypeSystem::GetTypeTemplateArgument(opaque_compiler_type_t type,
                                                 size_t idx, bool expand_pack) { … }

std::optional<CompilerType::IntegralTemplateArgument>
TypeSystem::GetIntegralTemplateArgument(opaque_compiler_type_t type, size_t idx,
                                        bool expand_pack) { … }

LazyBool TypeSystem::ShouldPrintAsOneLiner(void *type, ValueObject *valobj) { … }

bool TypeSystem::IsMeaninglessWithoutDynamicResolution(void *type) { … }

ConstString TypeSystem::DeclGetMangledName(void *opaque_decl) { … }

CompilerDeclContext TypeSystem::DeclGetDeclContext(void *opaque_decl) { … }

CompilerType TypeSystem::DeclGetFunctionReturnType(void *opaque_decl) { … }

size_t TypeSystem::DeclGetFunctionNumArguments(void *opaque_decl) { … }

CompilerType TypeSystem::DeclGetFunctionArgumentType(void *opaque_decl,
                                                     size_t arg_idx) { … }

std::vector<lldb_private::CompilerContext>
TypeSystem::DeclGetCompilerContext(void *opaque_decl) { … }

std::vector<lldb_private::CompilerContext>
TypeSystem::DeclContextGetCompilerContext(void *opaque_decl_ctx) { … }

std::vector<CompilerDecl>
TypeSystem::DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
                                      bool ignore_imported_decls) { … }

std::unique_ptr<UtilityFunction>
TypeSystem::CreateUtilityFunction(std::string text, std::string name) { … }

std::optional<llvm::json::Value> TypeSystem::ReportStatistics() { … }

CompilerDeclContext
TypeSystem::GetCompilerDeclContextForType(const CompilerType &type) { … }

#pragma mark TypeSystemMap

TypeSystemMap::TypeSystemMap() : … { … }

TypeSystemMap::~TypeSystemMap() = default;

void TypeSystemMap::Clear() { … }

void TypeSystemMap::ForEach(
    std::function<bool(lldb::TypeSystemSP)> const &callback) { … }

llvm::Expected<lldb::TypeSystemSP> TypeSystemMap::GetTypeSystemForLanguage(
    lldb::LanguageType language,
    std::optional<CreateCallback> create_callback) { … }

llvm::Expected<lldb::TypeSystemSP>
TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
                                        Module *module, bool can_create) { … }

llvm::Expected<lldb::TypeSystemSP>
TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
                                        Target *target, bool can_create) { … }

bool TypeSystem::SupportsLanguageStatic(lldb::LanguageType language) { … }
llvm/lldb/source/Symbol/TypeSystem.cpp
