SymbolFile.h revision a8b56238ce138e70433a0ce0b4218c9257beae38 
1//===-- SymbolFile.h --------------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef liblldb_SymbolFile_h_
11#define liblldb_SymbolFile_h_
12
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"
18
19namespace lldb_private {
20
21class SymbolFile :
22    public PluginInterface
23{
24public:
25    //------------------------------------------------------------------
26    // Symbol file ability bits.
27    //
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    //------------------------------------------------------------------
33    enum Abilities
34    {
35        CompileUnits                        = (1u << 0),
36        LineTables                          = (1u << 1),
37        Functions                           = (1u << 2),
38        Blocks                              = (1u << 3),
39        GlobalVariables                     = (1u << 4),
40        LocalVariables                      = (1u << 5),
41        VariableTypes                       = (1u << 6),
42        kAllAbilities                       =((1u << 7) - 1u)
43    };
44
45    static SymbolFile *
46    FindPlugin (ObjectFile* obj_file);
47
48    //------------------------------------------------------------------
49    // Constructors and Destructors
50    //------------------------------------------------------------------
51    SymbolFile(ObjectFile* obj_file) :
52        m_obj_file(obj_file),
53        m_abilities(0),
54        m_calculated_abilities(false)
55    {
56    }
57
58    virtual
59    ~SymbolFile()
60    {
61    }
62
63    //------------------------------------------------------------------
64    /// Get a mask of what this symbol file supports for the object file
65    /// that it was constructed with.
66    ///
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.
86    ///
87    /// @return
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 ()
93    {
94        if (!m_calculated_abilities)
95        {
96            m_abilities = CalculateAbilities();
97            m_calculated_abilities = true;
98        }
99
100        return m_abilities;
101    }
102
103    virtual uint32_t        CalculateAbilities() = 0;
104
105    //------------------------------------------------------------------
106    /// Initialize the SymbolFile object.
107    ///
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() {}
115
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;
122
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 lldb::clang_type_t ResolveClangOpaqueTypeDefinition (lldb::clang_type_t 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,
144                                      uint32_t type_mask,
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;
152
153    ObjectFile*             GetObjectFile() { return m_obj_file; }
154    const ObjectFile*       GetObjectFile() const { return m_obj_file; }
155
156protected:
157    ObjectFile*             m_obj_file; // The object file that symbols can be extracted from.
158    uint32_t                m_abilities;
159    bool                    m_calculated_abilities;
160private:
161    DISALLOW_COPY_AND_ASSIGN (SymbolFile);
162};
163
164
165} // namespace lldb_private
166
167#endif  // liblldb_SymbolFile_h_
168