1 //===-- ClangPersistentVariables.h ------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef liblldb_ClangPersistentVariables_h_ 10 #define liblldb_ClangPersistentVariables_h_ 11 12 #include "llvm/ADT/DenseMap.h" 13 14 #include "ClangExpressionVariable.h" 15 #include "ClangModulesDeclVendor.h" 16 17 #include "lldb/Expression/ExpressionVariable.h" 18 19 namespace lldb_private { 20 21 /// \class ClangPersistentVariables ClangPersistentVariables.h 22 /// "lldb/Expression/ClangPersistentVariables.h" Manages persistent values 23 /// that need to be preserved between expression invocations. 24 /// 25 /// A list of variables that can be accessed and updated by any expression. See 26 /// ClangPersistentVariable for more discussion. Also provides an increasing, 27 /// 0-based counter for naming result variables. 28 class ClangPersistentVariables : public PersistentExpressionState { 29 public: 30 ClangPersistentVariables(); 31 32 ~ClangPersistentVariables() override = default; 33 34 // llvm casting support 35 static bool classof(const PersistentExpressionState *pv) { 36 return pv->getKind() == PersistentExpressionState::eKindClang; 37 } 38 39 lldb::ExpressionVariableSP 40 CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) override; 41 42 lldb::ExpressionVariableSP CreatePersistentVariable( 43 ExecutionContextScope *exe_scope, ConstString name, 44 const CompilerType &compiler_type, lldb::ByteOrder byte_order, 45 uint32_t addr_byte_size) override; 46 47 void RemovePersistentVariable(lldb::ExpressionVariableSP variable) override; 48 49 llvm::StringRef GetPersistentVariablePrefix(bool is_error) const override { 50 return "$"; 51 } 52 53 /// Returns the next file name that should be used for user expressions. 54 std::string GetNextExprFileName() { 55 std::string name; 56 name.append("<user expression "); 57 name.append(std::to_string(m_next_user_file_id++)); 58 name.append(">"); 59 return name; 60 } 61 62 llvm::Optional<CompilerType> 63 GetCompilerTypeFromPersistentDecl(ConstString type_name) override; 64 65 void RegisterPersistentDecl(ConstString name, clang::NamedDecl *decl, 66 ClangASTContext *ctx); 67 68 clang::NamedDecl *GetPersistentDecl(ConstString name); 69 70 void AddHandLoadedClangModule(ClangModulesDeclVendor::ModuleID module) { 71 m_hand_loaded_clang_modules.push_back(module); 72 } 73 74 const ClangModulesDeclVendor::ModuleVector &GetHandLoadedClangModules() { 75 return m_hand_loaded_clang_modules; 76 } 77 78 private: 79 /// The counter used by GetNextExprFileName. 80 uint32_t m_next_user_file_id = 0; 81 // The counter used by GetNextPersistentVariableName 82 uint32_t m_next_persistent_variable_id = 0; 83 84 struct PersistentDecl { 85 /// The persistent decl. 86 clang::NamedDecl *m_decl = nullptr; 87 /// The ClangASTContext for the ASTContext of m_decl. 88 ClangASTContext *m_context = nullptr; 89 }; 90 91 typedef llvm::DenseMap<const char *, PersistentDecl> PersistentDeclMap; 92 PersistentDeclMap 93 m_persistent_decls; ///< Persistent entities declared by the user. 94 95 ClangModulesDeclVendor::ModuleVector 96 m_hand_loaded_clang_modules; ///< These are Clang modules we hand-loaded; 97 ///these are the highest- 98 ///< priority source for macros. 99 }; 100 101 } // namespace lldb_private 102 103 #endif // liblldb_ClangPersistentVariables_h_ 104