1 //===-- SymbolFile.h --------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef liblldb_SymbolFile_h_
11 #define liblldb_SymbolFile_h_
13 #include "lldb/lldb-private.h"
14 #include "lldb/Core/PluginInterface.h"
15 #include "lldb/Symbol/ClangASTType.h"
16 #include "lldb/Symbol/ClangNamespaceDecl.h"
17 #include "lldb/Symbol/Type.h"
19 namespace lldb_private {
22 public PluginInterface
25 //------------------------------------------------------------------
26 // Symbol file ability bits.
28 // Each symbol file can claim to support one or more symbol file
29 // abilities. These get returned from SymbolFile::GetAbilities().
30 // These help us to determine which plug-in will be best to load
31 // the debug information found in files.
32 //------------------------------------------------------------------
35 CompileUnits = (1u << 0),
36 LineTables = (1u << 1),
37 Functions = (1u << 2),
39 GlobalVariables = (1u << 4),
40 LocalVariables = (1u << 5),
41 VariableTypes = (1u << 6),
42 kAllAbilities =((1u << 7) - 1u)
46 FindPlugin (ObjectFile* obj_file);
48 //------------------------------------------------------------------
49 // Constructors and Destructors
50 //------------------------------------------------------------------
51 SymbolFile(ObjectFile* obj_file) :
54 m_calculated_abilities(false)
63 //------------------------------------------------------------------
64 /// Get a mask of what this symbol file supports for the object file
65 /// that it was constructed with.
67 /// Each symbol file gets to respond with a mask of abilities that
68 /// it supports for each object file. This happens when we are
69 /// trying to figure out which symbol file plug-in will get used
70 /// for a given object file. The plug-in that resoonds with the
71 /// best mix of "SymbolFile::Abilities" bits set, will get chosen to
72 /// be the symbol file parser. This allows each plug-in to check for
73 /// sections that contain data a symbol file plug-in would need. For
74 /// example the DWARF plug-in requires DWARF sections in a file that
75 /// contain debug information. If the DWARF plug-in doesn't find
76 /// these sections, it won't respond with many ability bits set, and
77 /// we will probably fall back to the symbol table SymbolFile plug-in
78 /// which uses any information in the symbol table. Also, plug-ins
79 /// might check for some specific symbols in a symbol table in the
80 /// case where the symbol table contains debug information (STABS
81 /// and COFF). Not a lot of work should happen in these functions
82 /// as the plug-in might not get selected due to another plug-in
83 /// having more abilities. Any initialization work should be saved
84 /// for "void SymbolFile::InitializeObject()" which will get called
85 /// on the SymbolFile object with the best set of abilities.
88 /// A uint32_t mask containing bits from the SymbolFile::Abilities
89 /// enumeration. Any bits that are set represent an ability that
90 /// this symbol plug-in can parse from the object file.
91 ///------------------------------------------------------------------
92 uint32_t GetAbilities ()
94 if (!m_calculated_abilities)
96 m_abilities = CalculateAbilities();
97 m_calculated_abilities = true;
103 virtual uint32_t CalculateAbilities() = 0;
105 //------------------------------------------------------------------
106 /// Initialize the SymbolFile object.
108 /// The SymbolFile object with the best set of abilities (detected
109 /// in "uint32_t SymbolFile::GetAbilities()) will have this function
110 /// called if it is chosen to parse an object file. More complete
111 /// initialization can happen in this function which will get called
112 /// prior to any other functions in the SymbolFile protocol.
113 //------------------------------------------------------------------
114 virtual void InitializeObject() {}
116 //------------------------------------------------------------------
117 // Compile Unit function calls
118 //------------------------------------------------------------------
119 // Approach 1 - iterator
120 virtual uint32_t GetNumCompileUnits() = 0;
121 virtual lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) = 0;
123 virtual lldb::LanguageType ParseCompileUnitLanguage (const SymbolContext& sc) = 0;
124 virtual size_t ParseCompileUnitFunctions (const SymbolContext& sc) = 0;
125 virtual bool ParseCompileUnitLineTable (const SymbolContext& sc) = 0;
126 virtual bool ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files) = 0;
127 virtual size_t ParseFunctionBlocks (const SymbolContext& sc) = 0;
128 virtual size_t ParseTypes (const SymbolContext& sc) = 0;
129 virtual size_t ParseVariablesForContext (const SymbolContext& sc) = 0;
130 virtual Type* ResolveTypeUID (lldb::user_id_t type_uid) = 0;
131 virtual bool ResolveClangOpaqueTypeDefinition (ClangASTType &clang_type) = 0;
132 virtual clang::DeclContext* GetClangDeclContextForTypeUID (const lldb_private::SymbolContext &sc, lldb::user_id_t type_uid) { return NULL; }
133 virtual clang::DeclContext* GetClangDeclContextContainingTypeUID (lldb::user_id_t type_uid) { return NULL; }
134 virtual uint32_t ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc) = 0;
135 virtual uint32_t ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list) = 0;
136 virtual uint32_t FindGlobalVariables (const ConstString &name, const ClangNamespaceDecl *namespace_decl, bool append, uint32_t max_matches, VariableList& variables) = 0;
137 virtual uint32_t FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables) = 0;
138 virtual uint32_t FindFunctions (const ConstString &name, const ClangNamespaceDecl *namespace_decl, uint32_t name_type_mask, bool include_inlines, bool append, SymbolContextList& sc_list) = 0;
139 virtual uint32_t FindFunctions (const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list) = 0;
140 virtual uint32_t FindTypes (const SymbolContext& sc, const ConstString &name, const ClangNamespaceDecl *namespace_decl, bool append, uint32_t max_matches, TypeList& types) = 0;
141 // virtual uint32_t FindTypes (const SymbolContext& sc, const RegularExpression& regex, bool append, uint32_t max_matches, TypeList& types) = 0;
142 virtual TypeList * GetTypeList ();
143 virtual size_t GetTypes (lldb_private::SymbolContextScope *sc_scope,
145 lldb_private::TypeList &type_list) = 0;
146 virtual ClangASTContext &
147 GetClangASTContext ();
148 virtual ClangNamespaceDecl
149 FindNamespace (const SymbolContext& sc,
150 const ConstString &name,
151 const ClangNamespaceDecl *parent_namespace_decl) = 0;
153 ObjectFile* GetObjectFile() { return m_obj_file; }
154 const ObjectFile* GetObjectFile() const { return m_obj_file; }
157 ObjectFile* m_obj_file; // The object file that symbols can be extracted from.
158 uint32_t m_abilities;
159 bool m_calculated_abilities;
161 DISALLOW_COPY_AND_ASSIGN (SymbolFile);
165 } // namespace lldb_private
167 #endif // liblldb_SymbolFile_h_