Revert to dumb pointers for compatibility within line info interfaces, but add Ptr...
[dyninst.git] / symtabAPI / h / Module.h
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #ifndef __MODULE__H__
32 #define __MODULE__H__
33  
34 #include "symutil.h"
35 #include "Symbol.h"
36
37 #include "Annotatable.h"
38 #include "Serialization.h"
39 #include "IBSTree.h"
40 #include "IBSTree-fast.h"
41 #if defined(cap_dwarf)
42 #include "libdwarf.h"
43 #endif
44 #include <boost/shared_ptr.hpp>
45 #include "RangeLookup.h"
46
47 #include "StringTable.h"
48
49 namespace Dyninst{
50 namespace SymtabAPI{
51
52 class typeCollection;
53 class LineInformation;
54 class localVar;
55 class Symtab;
56
57
58 class SYMTAB_EXPORT Statement : public AddressRange
59 {
60         friend class Module;
61         friend class LineInformation;
62         Statement(int file_index, unsigned int line, unsigned int col = 0,
63              Offset start_addr = (Offset) -1L, Offset end_addr = (Offset) -1L) :
64     AddressRange(start_addr, end_addr),
65                         file_index_(file_index),
66       line_(line),
67             column_(col)
68       {
69       }
70         
71         unsigned int file_index_; // Maybe this should be module?
72         unsigned int line_;
73     unsigned int column_;
74         StringTablePtr strings_;
75 public:
76     StringTablePtr getStrings_() const;
77
78     void setStrings_(StringTablePtr strings_);
79
80 public:
81
82         Statement() : AddressRange(0,0), file_index_(0), line_(0), column_(0)  {}
83         struct StatementLess {
84                 bool operator () ( const Statement &lhs, const Statement &rhs ) const;
85         };
86
87         typedef StatementLess LineNoTupleLess;
88
89         bool operator==(const Statement &cmp) const;
90 //    bool operator==(const char* file) const {return strcmp(file, first) == 0; }
91     bool operator==(Offset addr) const {
92         return AddressRange::contains(addr);
93     }
94     bool operator<(Offset addr) const {
95         return startAddr() <= addr;
96     }
97     bool operator>(Offset addr) const {
98         return !((*this) < addr || (*this == addr));
99     }
100         ~Statement() {}
101
102         Offset startAddr() const { return first;}
103         Offset endAddr() const {return second;}
104         std::string getFile() const;
105     unsigned int getFileIndex() const { return file_index_; }
106         unsigned int getLine()const {return line_;}
107     unsigned int getColumn() const { return column_; }
108     struct addr_range {};
109     struct line_info {};
110     struct upper_bound {};
111
112     typedef Statement* Ptr;
113     typedef const Statement* ConstPtr;
114 //    typedef boost::shared_ptr<Statement> Ptr;
115 //    typedef boost::shared_ptr<const Statement> ConstPtr;
116
117 };
118 template <typename OS>
119 OS& operator<<(OS& os, const Statement& s)
120 {
121     os << "<statement>: [" << std::hex << s.startAddr() << ", " << s.endAddr() << std::dec << ") @ " << s.getFile()
122        << " (" << s.getFileIndex() << "): " << s.getLine();
123     return os;
124 }
125 template <typename OS>
126 OS& operator<<(OS& os, Statement* s)
127 {
128     os << "<statement>: [" << std::hex << s->startAddr() << ", " << s->endAddr() << std::dec << ") @ " << s->getFile()
129        << " (" << s->getFileIndex() << "): " << s->getLine();
130     return os;
131 }
132
133
134 typedef Statement LineNoTuple;
135 #define MODULE_ANNOTATABLE_CLASS AnnotatableSparse
136
137  class SYMTAB_EXPORT Module : public LookupInterface
138 {
139         friend class Symtab;
140
141         public:
142 #if defined(cap_dwarf)
143                         typedef Dwarf_Die DebugInfoT;
144 #else
145                         typedef void* DebugInfoT;
146 #endif
147
148         Module();
149         Module(supportedLanguages lang, Offset adr, std::string fullNm,
150                         Symtab *img);
151         Module(const Module &mod);
152         bool operator==(Module &mod);
153
154         const std::string &fileName() const;
155         const std::string &fullName() const;
156         bool setName(std::string newName);
157
158         supportedLanguages language() const;
159         void setLanguage(supportedLanguages lang);
160
161         Offset addr() const;
162         Symtab *exec() const;
163
164         bool isShared() const;
165         ~Module();
166
167         // Symbol output methods
168         virtual bool findSymbol(std::vector<Symbol *> &ret, 
169                                               const std::string& name,
170                                               Symbol::SymbolType sType = Symbol::ST_UNKNOWN, 
171                                               NameType nameType = anyName,
172                                               bool isRegex = false, 
173                                               bool checkCase = false,
174                                               bool includeUndefined = false);
175         virtual bool getAllSymbolsByType(std::vector<Symbol *> &ret, 
176                         Symbol::SymbolType sType);
177         virtual bool getAllSymbols(std::vector<Symbol *> &ret);
178
179
180         // Function based methods
181         bool getAllFunctions(std::vector<Function *>&ret);
182         bool findFunctionByEntryOffset(Function *&ret, const Offset offset);
183         bool findFunctionsByName(std::vector<Function *> &ret, const std::string& name,
184                         NameType nameType = anyName, 
185                         bool isRegex = false,
186                         bool checkCase = true);
187
188         // Variable based methods
189         bool findVariableByOffset(Variable *&ret, const Offset offset);
190         bool findVariablesByName(std::vector<Variable *> &ret, const std::string& name,
191                         NameType nameType = anyName, 
192                         bool isRegex = false, 
193                         bool checkCase = true);
194    bool getAllVariables(std::vector<Variable *> &ret);
195
196
197    // Type output methods
198    virtual bool findType(Type *&type, std::string name);
199    virtual bool findVariableType(Type *&type, std::string name);
200
201    std::vector<Type *> *getAllTypes();
202    std::vector<std::pair<std::string, Type *> > *getAllGlobalVars();
203
204    typeCollection *getModuleTypes();
205
206    /***** Local Variable Information *****/
207    bool findLocalVariable(std::vector<localVar *>&vars, std::string name);
208
209    /***** Line Number Information *****/
210    bool getAddressRanges(std::vector<AddressRange >&ranges,
211          std::string lineSource, unsigned int LineNo);
212    bool getSourceLines(std::vector<Statement::Ptr> &lines,
213          Offset addressInRange);
214    bool getSourceLines(std::vector<LineNoTuple> &lines,
215          Offset addressInRange);
216    bool getStatements(std::vector<Statement::Ptr> &statements);
217    LineInformation *getLineInformation();
218     LineInformation* parseLineInformation();
219
220                         bool setDefaultNamespacePrefix(std::string str);
221
222
223    //  Super secret private methods that aren't really private
224    typeCollection *getModuleTypesPrivate();
225    void setModuleTypes(typeCollection* tc) 
226    {
227      typeInfo_ = tc;
228    }
229    
230    bool setLineInfo(Dyninst::SymtabAPI::LineInformation *lineInfo);
231          void addRange(Dyninst::Address low, Dyninst::Address high);
232
233         void addDebugInfo(Module::DebugInfoT info);
234
235         void finalizeRanges();
236
237         private:
238    Dyninst::SymtabAPI::LineInformation* lineInfo_;
239    typeCollection* typeInfo_;
240         std::vector<Module::DebugInfoT> info_;
241    
242
243    std::string fileName_;                   // short file 
244    std::string fullName_;                   // full path to file 
245    supportedLanguages language_;
246    Offset addr_;                      // starting address of module
247    Symtab *exec_;
248     std::set<AddressRange > ranges;
249
250     StringTablePtr strings_;
251         public:
252             StringTablePtr & getStrings() ;
253
254         private:
255             bool ranges_finalized;
256
257             void finalizeOneRange(Address ext_s, Address ext_e) const;
258         };
259                 template <typename OS>
260                 OS& operator<<(OS& os, const Module& m)
261                 {
262                         os << m.fileName() << ": " << m.addr();
263                         return os;
264                 }
265                 template <typename OS>
266                 OS& operator<<(OS& os, Module* m)
267                 {
268                         os << m->fileName() << ": " << m->addr();
269                         return os;
270                 }
271
272 typedef Dyninst::SimpleInterval<Offset, Module*> ModRange;
273
274 inline bool operator==(Offset off, const ModRange& r) {
275     return (r.low() <= off) && (off < r.high());
276 }
277 inline bool operator==(const ModRange& r, Offset off) {
278     return off == r;
279 }
280 template<typename OS>
281 OS& operator<<(OS& os, const ModRange& m)
282 {
283     os << m.id() << ": [" << m.low() << ", " << m.high() << ")";
284     return os;
285 }
286
287
288 }//namespace SymtabAPI
289
290 }//namespace Dyninst
291
292
293 #endif