//===-- SymbolFileOnDemand.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_SYMBOLFILEONDEMAND_H

#define LLDB_SYMBOL_SYMBOLFILEONDEMAND_H

#include <mutex>

#include <optional>

#include <vector>

#include "lldb/Symbol/ObjectFile.h"

#include "lldb/Symbol/SymbolContext.h"

#include "lldb/Symbol/SymbolFile.h"

#include "lldb/Target/Statistics.h"

#include "lldb/Utility/ConstString.h"

#include "lldb/Utility/Flags.h"

#include "lldb/Utility/LLDBLog.h"

#include "lldb/Utility/Log.h"

#include "lldb/lldb-private.h"

namespace lldb_private {

/// SymbolFileOnDemand wraps an actual SymbolFile by providing

/// on demand symbol parsing/indexing to improve performance.

/// By default SymbolFileOnDemand will skip load the underlying

/// symbols. Any client can on demand hydrate the underlying

/// SymbolFile via SymbolFile::SetLoadDebugInfoEnabled().

class SymbolFileOnDemand : public lldb_private::SymbolFile {

  /// LLVM RTTI support.

  static char ID;

public:

  /// LLVM RTTI support.

  /// \{

  bool isA(const void *ClassID) const override {

    return ClassID == &ID || SymbolFile::isA(ClassID);

  }

  static bool classof(const SymbolFile *obj) { return obj->isA(&ID); }

  /// \}

  SymbolFileOnDemand(std::unique_ptr<SymbolFile> &&symbol_file);

  ~SymbolFileOnDemand() override;

  // PluginInterface protocol

  llvm::StringRef GetPluginName() override { return "ondemand"; }

  bool GetLoadDebugInfoEnabled() override { return m_debug_info_enabled; }

  void SetLoadDebugInfoEnabled() override;

  uint32_t GetNumCompileUnits() override;

  lldb::CompUnitSP GetCompileUnitAtIndex(uint32_t idx) override;

  SymbolFile *GetBackingSymbolFile() override { return m_sym_file_impl.get(); }

  uint32_t CalculateAbilities() override;

  std::recursive_mutex &GetModuleMutex() const override;

  lldb::LanguageType

  ParseLanguage(lldb_private::CompileUnit &comp_unit) override;

  lldb_private::XcodeSDK

  ParseXcodeSDK(lldb_private::CompileUnit &comp_unit) override;

  void InitializeObject() override;

  size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override;

  bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override;

  bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override;

  bool ForEachExternalModule(

      lldb_private::CompileUnit &, llvm::DenseSet<lldb_private::SymbolFile *> &,

      llvm::function_ref<bool(lldb_private::Module &)>) override;

  bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit,

                         lldb_private::FileSpecList &support_files) override;

  bool ParseIsOptimized(lldb_private::CompileUnit &comp_unit) override;

  size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;

  bool ParseImportedModules(

      const lldb_private::SymbolContext &sc,

      std::vector<lldb_private::SourceModule> &imported_modules) override;

  size_t ParseBlocksRecursive(lldb_private::Function &func) override;

  size_t

  ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;

  lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;

  std::optional<ArrayInfo> GetDynamicArrayInfoForUID(

      lldb::user_id_t type_uid,

      const lldb_private::ExecutionContext *exe_ctx) override;

  bool CompleteType(lldb_private::CompilerType &compiler_type) override;

  lldb_private::CompilerDecl GetDeclForUID(lldb::user_id_t uid) override;

  lldb_private::CompilerDeclContext

  GetDeclContextForUID(lldb::user_id_t uid) override;

  lldb_private::CompilerDeclContext

  GetDeclContextContainingUID(lldb::user_id_t uid) override;

  void

  ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;

  uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,

                                lldb::SymbolContextItem resolve_scope,

                                lldb_private::SymbolContext &sc) override;

  lldb_private::Status

  CalculateFrameVariableError(lldb_private::StackFrame &frame) override;

  uint32_t ResolveSymbolContext(

      const lldb_private::SourceLocationSpec &src_location_spec,

      lldb::SymbolContextItem resolve_scope,

      lldb_private::SymbolContextList &sc_list) override;

  void Dump(lldb_private::Stream &s) override;

  void DumpClangAST(lldb_private::Stream &s) override;

  void

  FindGlobalVariables(lldb_private::ConstString name,

                      const lldb_private::CompilerDeclContext &parent_decl_ctx,

                      uint32_t max_matches,

                      lldb_private::VariableList &variables) override;

  void FindGlobalVariables(const lldb_private::RegularExpression &regex,

                           uint32_t max_matches,

                           lldb_private::VariableList &variables) override;

  void FindFunctions(const lldb_private::Module::LookupInfo &lookup_info,

                     const lldb_private::CompilerDeclContext &parent_decl_ctx,

                     bool include_inlines,

                     lldb_private::SymbolContextList &sc_list) override;

  void FindFunctions(const lldb_private::RegularExpression &regex,

                     bool include_inlines,

                     lldb_private::SymbolContextList &sc_list) override;

  void GetMangledNamesForFunction(

      const std::string &scope_qualified_name,

      std::vector<lldb_private::ConstString> &mangled_names) override;

  void

  FindTypes(lldb_private::ConstString name,

            const lldb_private::CompilerDeclContext &parent_decl_ctx,

            uint32_t max_matches,

            llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,

            lldb_private::TypeMap &types) override;

  void FindTypes(llvm::ArrayRef<lldb_private::CompilerContext> pattern,

                 lldb_private::LanguageSet languages,

                 llvm::DenseSet<SymbolFile *> &searched_symbol_files,

                 lldb_private::TypeMap &types) override;

  void GetTypes(lldb_private::SymbolContextScope *sc_scope,

                lldb::TypeClass type_mask,

                lldb_private::TypeList &type_list) override;

  llvm::Expected<lldb::TypeSystemSP>

  GetTypeSystemForLanguage(lldb::LanguageType language) override;

  lldb_private::CompilerDeclContext

  FindNamespace(lldb_private::ConstString name,

                const lldb_private::CompilerDeclContext &parent_decl_ctx,

                bool only_root_namespaces) override;

  std::vector<std::unique_ptr<lldb_private::CallEdge>>

  ParseCallEdgesInFunction(UserID func_id) override;

  lldb::UnwindPlanSP

  GetUnwindPlan(const Address &address,

                const RegisterInfoResolver &resolver) override;

  llvm::Expected<lldb::addr_t> GetParameterStackSize(Symbol &symbol) override;

  void PreloadSymbols() override;

  uint64_t GetDebugInfoSize() override;

  lldb_private::StatsDuration::Duration GetDebugInfoParseTime() override;

  lldb_private::StatsDuration::Duration GetDebugInfoIndexTime() override;

  uint32_t GetAbilities() override;

  Symtab *GetSymtab() override { return m_sym_file_impl->GetSymtab(); }

  ObjectFile *GetObjectFile() override {

    return m_sym_file_impl->GetObjectFile();

  }

  const ObjectFile *GetObjectFile() const override {

    return m_sym_file_impl->GetObjectFile();

  }

  ObjectFile *GetMainObjectFile() override {

    return m_sym_file_impl->GetMainObjectFile();

  }

  void SectionFileAddressesChanged() override {

    return m_sym_file_impl->SectionFileAddressesChanged();

  }

  bool GetDebugInfoIndexWasLoadedFromCache() const override {

    return m_sym_file_impl->GetDebugInfoIndexWasLoadedFromCache();

  }

  void SetDebugInfoIndexWasLoadedFromCache() override {

    m_sym_file_impl->SetDebugInfoIndexWasLoadedFromCache();

  }

  bool GetDebugInfoIndexWasSavedToCache() const override {

    return m_sym_file_impl->GetDebugInfoIndexWasSavedToCache();

  }

  void SetDebugInfoIndexWasSavedToCache() override {

    m_sym_file_impl->SetDebugInfoIndexWasSavedToCache();

  }

  bool GetDebugInfoHadFrameVariableErrors() const override {

    return m_sym_file_impl->GetDebugInfoHadFrameVariableErrors();

  }

  void SetDebugInfoHadFrameVariableErrors() override {

    return m_sym_file_impl->SetDebugInfoHadFrameVariableErrors();

  }

  lldb::TypeSP MakeType(lldb::user_id_t uid, ConstString name,

                        std::optional<uint64_t> byte_size,

                        SymbolContextScope *context,

                        lldb::user_id_t encoding_uid,

                        Type::EncodingDataType encoding_uid_type,

                        const Declaration &decl,

                        const CompilerType &compiler_qual_type,

                        Type::ResolveState compiler_type_resolve_state,

                        uint32_t opaque_payload = 0) override {

    return m_sym_file_impl->MakeType(

        uid, name, byte_size, context, encoding_uid, encoding_uid_type, decl,

        compiler_qual_type, compiler_type_resolve_state, opaque_payload);

  }

  lldb::TypeSP CopyType(const lldb::TypeSP &other_type) override {

    return m_sym_file_impl->CopyType(other_type);

  }

private:

  Log *GetLog() const { return ::lldb_private::GetLog(LLDBLog::OnDemand); }

  ConstString GetSymbolFileName() {

    return GetObjectFile()->GetFileSpec().GetFilename();

  }

private:

  bool m_debug_info_enabled = false;

  bool m_preload_symbols = false;

  std::unique_ptr<SymbolFile> m_sym_file_impl;

};

} // namespace lldb_private

#endif // LLDB_SYMBOL_SYMBOLFILEONDEMAND_H