//===-- Type.h --------------------------------------------------*- C++ -*-===//

//

// 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

//

//===----------------------------------------------------------------------===//

#ifndef LLDB_SYMBOL_TYPE_H

#define LLDB_SYMBOL_TYPE_H

#include "lldb/Core/Declaration.h"

#include "lldb/Symbol/CompilerDecl.h"

#include "lldb/Symbol/CompilerType.h"

#include "lldb/Utility/ConstString.h"

#include "lldb/Utility/UserID.h"

#include "lldb/lldb-private.h"

#include "llvm/ADT/APSInt.h"

#include <optional>

#include <set>

namespace lldb_private {

class SymbolFileCommon;

/// CompilerContext allows an array of these items to be passed to perform

/// detailed lookups in SymbolVendor and SymbolFile functions.

struct CompilerContext {

  CompilerContext(CompilerContextKind t, ConstString n) : kind(t), name(n) {}

  bool operator==(const CompilerContext &rhs) const {

    return kind == rhs.kind && 
name == rhs.name159
;

  }

  bool operator!=(const CompilerContext &rhs) const { return !(*this == rhs); }

  void Dump() const;

  CompilerContextKind kind;

  ConstString name;

};

/// Match \p context_chain against \p pattern, which may contain "Any"

/// kinds. The \p context_chain should *not* contain any "Any" kinds.

bool contextMatches(llvm::ArrayRef<CompilerContext> context_chain,

                    llvm::ArrayRef<CompilerContext> pattern);

class SymbolFileType : public std::enable_shared_from_this<SymbolFileType>,

                       public UserID {

public:

  SymbolFileType(SymbolFile &symbol_file, lldb::user_id_t uid)

      : UserID(uid), m_symbol_file(symbol_file) {}

  SymbolFileType(SymbolFile &symbol_file, const lldb::TypeSP &type_sp);

  ~SymbolFileType() = default;

  Type *operator->() { return GetType(); }

  Type *GetType();

  SymbolFile &GetSymbolFile() const { return m_symbol_file; }

protected:

  SymbolFile &m_symbol_file;

  lldb::TypeSP m_type_sp;

};

class Type : public std::enable_shared_from_this<Type>, public UserID {

public:

  enum EncodingDataType {

    /// Invalid encoding.

    eEncodingInvalid,

    /// This type is the type whose UID is m_encoding_uid.

    eEncodingIsUID,

    /// This type is the type whose UID is m_encoding_uid with the const

    /// qualifier added.

    eEncodingIsConstUID,

    /// This type is the type whose UID is m_encoding_uid with the restrict

    /// qualifier added.

    eEncodingIsRestrictUID,

    /// This type is the type whose UID is m_encoding_uid with the volatile

    /// qualifier added.

    eEncodingIsVolatileUID,

    /// This type is alias to a type whose UID is m_encoding_uid.

    eEncodingIsTypedefUID,

    /// This type is pointer to a type whose UID is m_encoding_uid.

    eEncodingIsPointerUID,

    /// This type is L value reference to a type whose UID is m_encoding_uid.

    eEncodingIsLValueReferenceUID,

    /// This type is R value reference to a type whose UID is m_encoding_uid.

    eEncodingIsRValueReferenceUID,

    /// This type is the type whose UID is m_encoding_uid as an atomic type.

    eEncodingIsAtomicUID,

    /// This type is the synthetic type whose UID is m_encoding_uid.

    eEncodingIsSyntheticUID

  };

  enum class ResolveState : unsigned char {

    Unresolved = 0,

    Forward = 1,

    Layout = 2,

    Full = 3

  };

  void Dump(Stream *s, bool show_context,

            lldb::DescriptionLevel level = lldb::eDescriptionLevelFull);

  void DumpTypeName(Stream *s);

  /// Since Type instances only keep a "SymbolFile *" internally, other classes

  /// like TypeImpl need make sure the module is still around before playing

  /// with

  /// Type instances. They can store a weak pointer to the Module;

  lldb::ModuleSP GetModule();

  /// GetModule may return module for compile unit's object file.

  /// GetExeModule returns module for executable object file that contains

  /// compile unit where type was actually defined.

  /// GetModule and GetExeModule may return the same value.

  lldb::ModuleSP GetExeModule();

  void GetDescription(Stream *s, lldb::DescriptionLevel level, bool show_name,

                      ExecutionContextScope *exe_scope);

  SymbolFile *GetSymbolFile() { return m_symbol_file; }

  const SymbolFile *GetSymbolFile() const { return m_symbol_file; }

  ConstString GetName();

  ConstString GetBaseName();

  std::optional<uint64_t> GetByteSize(ExecutionContextScope *exe_scope);

  uint32_t GetNumChildren(bool omit_empty_base_classes);

  bool IsAggregateType();

  // Returns if the type is a templated decl. Does not look through typedefs.

  bool IsTemplateType();

  bool IsValidType() { return m_encoding_uid_type != eEncodingInvalid; }

  bool IsTypedef() { return m_encoding_uid_type == eEncodingIsTypedefUID; }

  lldb::TypeSP GetTypedefType();

  ConstString GetName() const { return m_name; }

  ConstString GetQualifiedName();

  void DumpValue(ExecutionContext *exe_ctx, Stream *s,

                 const DataExtractor &data, uint32_t data_offset,

                 bool show_type, bool show_summary, bool verbose,

                 lldb::Format format = lldb::eFormatDefault);

  bool DumpValueInMemory(ExecutionContext *exe_ctx, Stream *s,

                         lldb::addr_t address, AddressType address_type,

                         bool show_types, bool show_summary, bool verbose);

  bool ReadFromMemory(ExecutionContext *exe_ctx, lldb::addr_t address,

                      AddressType address_type, DataExtractor &data);

  bool WriteToMemory(ExecutionContext *exe_ctx, lldb::addr_t address,

                     AddressType address_type, DataExtractor &data);

  lldb::Format GetFormat();

  lldb::Encoding GetEncoding(uint64_t &count);

  SymbolContextScope *GetSymbolContextScope() { return m_context; }

  const SymbolContextScope *GetSymbolContextScope() const { return m_context; }

  void SetSymbolContextScope(SymbolContextScope *context) {

    m_context = context;

  }

  const lldb_private::Declaration &GetDeclaration() const;

  // Get the clang type, and resolve definitions for any

  // class/struct/union/enum types completely.

  CompilerType GetFullCompilerType();

  // Get the clang type, and resolve definitions enough so that the type could

  // have layout performed. This allows ptrs and refs to

  // class/struct/union/enum types remain forward declarations.

  CompilerType GetLayoutCompilerType();

  // Get the clang type and leave class/struct/union/enum types as forward

  // declarations if they haven't already been fully defined.

  CompilerType GetForwardCompilerType();

  static int Compare(const Type &a, const Type &b);

  // From a fully qualified typename, split the type into the type basename and

  // the remaining type scope (namespaces/classes).

  static bool GetTypeScopeAndBasename(llvm::StringRef name,

                                      llvm::StringRef &scope,

                                      llvm::StringRef &basename,

                                      lldb::TypeClass &type_class);

  void SetEncodingType(Type *encoding_type) { m_encoding_type = encoding_type; }

  uint32_t GetEncodingMask();

  typedef uint32_t Payload;

  /// Return the language-specific payload.

  Payload GetPayload() { return m_payload; }

  /// Return the language-specific payload.

  void SetPayload(Payload opaque_payload) { m_payload = opaque_payload; }

protected:

  ConstString m_name;

  SymbolFile *m_symbol_file = nullptr;

  /// The symbol context in which this type is defined.

  SymbolContextScope *m_context = nullptr;

  Type *m_encoding_type = nullptr;

  lldb::user_id_t m_encoding_uid = LLDB_INVALID_UID;

  EncodingDataType m_encoding_uid_type = eEncodingInvalid;

  uint64_t m_byte_size : 63;

  uint64_t m_byte_size_has_value : 1;

  Declaration m_decl;

  CompilerType m_compiler_type;

  ResolveState m_compiler_type_resolve_state = ResolveState::Unresolved;

  /// Language-specific flags.

  Payload m_payload;

  Type *GetEncodingType();

  bool ResolveCompilerType(ResolveState compiler_type_resolve_state);

private:

  /// Only allow Symbol File to create types, as they should own them by keeping

  /// them in their TypeList. \see SymbolFileCommon::MakeType() reference in the

  /// header documentation here so users will know what function to use if the

  /// get a compile error.

  friend class lldb_private::SymbolFileCommon;

  Type(lldb::user_id_t uid, SymbolFile *symbol_file, ConstString name,

       std::optional<uint64_t> byte_size, SymbolContextScope *context,

       lldb::user_id_t encoding_uid, EncodingDataType encoding_uid_type,

       const Declaration &decl, const CompilerType &compiler_qual_type,

       ResolveState compiler_type_resolve_state, uint32_t opaque_payload = 0);

  // This makes an invalid type.  Used for functions that return a Type when

  // they get an error.

  Type();

  Type(Type &t) = default;

  Type(Type &&t) = default;

  Type &operator=(const Type &t) = default;

  Type &operator=(Type &&t) = default;

};

// the two classes here are used by the public API as a backend to the SBType

// and SBTypeList classes

class TypeImpl {

public:

  TypeImpl() = default;

  ~TypeImpl() = default;

  TypeImpl(const lldb::TypeSP &type_sp);

  TypeImpl(const CompilerType &compiler_type);

  TypeImpl(const lldb::TypeSP &type_sp, const CompilerType &dynamic);

  TypeImpl(const CompilerType &compiler_type, const CompilerType &dynamic);

  void SetType(const lldb::TypeSP &type_sp);

  void SetType(const CompilerType &compiler_type);

  void SetType(const lldb::TypeSP &type_sp, const CompilerType &dynamic);

  void SetType(const CompilerType &compiler_type, const CompilerType &dynamic);

  bool operator==(const TypeImpl &rhs) const;

  bool operator!=(const TypeImpl &rhs) const;

  bool IsValid() const;

  explicit operator bool() const;

  void Clear();

  lldb::ModuleSP GetModule() const;

  ConstString GetName() const;

  ConstString GetDisplayTypeName() const;

  TypeImpl GetPointerType() const;

  TypeImpl GetPointeeType() const;

  TypeImpl GetReferenceType() const;

  TypeImpl GetTypedefedType() const;

  TypeImpl GetDereferencedType() const;

  TypeImpl GetUnqualifiedType() const;

  TypeImpl GetCanonicalType() const;

  CompilerType GetCompilerType(bool prefer_dynamic);

  CompilerType::TypeSystemSPWrapper GetTypeSystem(bool prefer_dynamic);

  bool GetDescription(lldb_private::Stream &strm,

                      lldb::DescriptionLevel description_level);

private:

  bool CheckModule(lldb::ModuleSP &module_sp) const;

  bool CheckExeModule(lldb::ModuleSP &module_sp) const;

  bool CheckModuleCommon(const lldb::ModuleWP &input_module_wp,

                         lldb::ModuleSP &module_sp) const;

  lldb::ModuleWP m_module_wp;

  lldb::ModuleWP m_exe_module_wp;

  CompilerType m_static_type;

  CompilerType m_dynamic_type;

};

class TypeListImpl {

public:

  TypeListImpl() = default;

  void Append(const lldb::TypeImplSP &type) { m_content.push_back(type); }

  class AppendVisitor {

  public:

    AppendVisitor(TypeListImpl &type_list) : m_type_list(type_list) {}

    void operator()(const lldb::TypeImplSP &type) { m_type_list.Append(type); }

  private:

    TypeListImpl &m_type_list;

  };

  void Append(const lldb_private::TypeList &type_list);

  lldb::TypeImplSP GetTypeAtIndex(size_t idx) {

    lldb::TypeImplSP type_sp;

    if (idx < GetSize())

      type_sp = m_content[idx];

    return type_sp;

  }

  size_t GetSize() { return m_content.size(); }

private:

  std::vector<lldb::TypeImplSP> m_content;

};

class TypeMemberImpl {

public:

  TypeMemberImpl() = default;

  TypeMemberImpl(const lldb::TypeImplSP &type_impl_sp, uint64_t bit_offset,

                 ConstString name, uint32_t bitfield_bit_size = 0,

                 bool is_bitfield = false)

      : m_type_impl_sp(type_impl_sp), m_bit_offset(bit_offset), m_name(name),

        m_bitfield_bit_size(bitfield_bit_size), m_is_bitfield(is_bitfield) {}

  TypeMemberImpl(const lldb::TypeImplSP &type_impl_sp, uint64_t bit_offset)

      : m_type_impl_sp(type_impl_sp), m_bit_offset(bit_offset),

        m_bitfield_bit_size(0), m_is_bitfield(false) {

    if (m_type_impl_sp)

      m_name = m_type_impl_sp->GetName();

  }

  const lldb::TypeImplSP &GetTypeImpl() { return m_type_impl_sp; }

  ConstString GetName() const { return m_name; }

  uint64_t GetBitOffset() const { return m_bit_offset; }

  uint32_t GetBitfieldBitSize() const { return m_bitfield_bit_size; }

  void SetBitfieldBitSize(uint32_t bitfield_bit_size) {

    m_bitfield_bit_size = bitfield_bit_size;

  }

  bool GetIsBitfield() const { return m_is_bitfield; }

  void SetIsBitfield(bool is_bitfield) { m_is_bitfield = is_bitfield; }

protected:

  lldb::TypeImplSP m_type_impl_sp;

  uint64_t m_bit_offset = 0;

  ConstString m_name;

  uint32_t m_bitfield_bit_size = 0; // Bit size for bitfield members only

  bool m_is_bitfield = false;

};

///

/// Sometimes you can find the name of the type corresponding to an object, but

/// we don't have debug

/// information for it.  If that is the case, you can return one of these

/// objects, and then if it

/// has a full type, you can use that, but if not at least you can print the

/// name for informational

/// purposes.

///

class TypeAndOrName {

public:

  TypeAndOrName() = default;

  TypeAndOrName(lldb::TypeSP &type_sp);

  TypeAndOrName(const CompilerType &compiler_type);

  TypeAndOrName(const char *type_str);

  TypeAndOrName(ConstString &type_const_string);

  bool operator==(const TypeAndOrName &other) const;

  bool operator!=(const TypeAndOrName &other) const;

  ConstString GetName() const;

  CompilerType GetCompilerType() const { return m_compiler_type; }

  void SetName(ConstString type_name);

  void SetName(const char *type_name_cstr);

  void SetTypeSP(lldb::TypeSP type_sp);

  void SetCompilerType(CompilerType compiler_type);

  bool IsEmpty() const;

  bool HasName() const;

  bool HasCompilerType() const;

  bool HasType() const { return HasCompilerType(); }

  void Clear();

  explicit operator bool() { return !IsEmpty(); }

private:

  CompilerType m_compiler_type;

  ConstString m_type_name;

};

class TypeMemberFunctionImpl {

public:

  TypeMemberFunctionImpl() = default;

  TypeMemberFunctionImpl(const CompilerType &type, const CompilerDecl &decl,

                         const std::string &name,

                         const lldb::MemberFunctionKind &kind)

      : m_type(type), m_decl(decl), m_name(name), m_kind(kind) {}

  bool IsValid();

  ConstString GetName() const;

  ConstString GetMangledName() const;

  CompilerType GetType() const;

  CompilerType GetReturnType() const;

  size_t GetNumArguments() const;

  CompilerType GetArgumentAtIndex(size_t idx) const;

  lldb::MemberFunctionKind GetKind() const;

  bool GetDescription(Stream &stream);

protected:

  std::string GetPrintableTypeName();

private:

  CompilerType m_type;

  CompilerDecl m_decl;

  ConstString m_name;

  lldb::MemberFunctionKind m_kind = lldb::eMemberFunctionKindUnknown;

};

class TypeEnumMemberImpl {

public:

  TypeEnumMemberImpl() : m_name("<invalid>") {}

  TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp, ConstString name,

                     const llvm::APSInt &value);

  TypeEnumMemberImpl(const TypeEnumMemberImpl &rhs) = default;

  TypeEnumMemberImpl &operator=(const TypeEnumMemberImpl &rhs);

  bool IsValid() { return m_valid; }

  ConstString GetName() const { return m_name; }

  const lldb::TypeImplSP &GetIntegerType() const { return m_integer_type_sp; }

  uint64_t GetValueAsUnsigned() const { return m_value.getZExtValue(); }

  int64_t GetValueAsSigned() const { return m_value.getSExtValue(); }

protected:

  lldb::TypeImplSP m_integer_type_sp;

  ConstString m_name;

  llvm::APSInt m_value;

  bool m_valid = false;

};

class TypeEnumMemberListImpl {

public:

  TypeEnumMemberListImpl() = default;

  void Append(const lldb::TypeEnumMemberImplSP &type) {

    m_content.push_back(type);

  }

  void Append(const lldb_private::TypeEnumMemberListImpl &type_list);

  lldb::TypeEnumMemberImplSP GetTypeEnumMemberAtIndex(size_t idx) {

    lldb::TypeEnumMemberImplSP enum_member;

    if (idx < GetSize())

      enum_member = m_content[idx];

    return enum_member;

  }

  size_t GetSize() { return m_content.size(); }

private:

  std::vector<lldb::TypeEnumMemberImplSP> m_content;

};

} // namespace lldb_private

#endif // LLDB_SYMBOL_TYPE_H