Correct static initialization for built in & standard types in Symtab
[dyninst.git] / symtabAPI / h / Collections.h
1 /*
2  * Copyright (c) 1996-2011 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #ifndef _Collections_h_
33 #define _Collections_h_
34
35 #include "Type.h"
36 #include "Variable.h"
37 #include "Serialization.h"
38
39 namespace Dyninst {
40
41 namespace SymtabAPI {
42
43 class Module;
44 class Symtab;
45 class localVar;
46
47 /*
48  * This class contains a collection of local variables.
49  * Each function will have one of these objects associated with it.
50  * This object will store all the local variables within this function.
51  * Note: This class is unaware of scope.
52  */
53 class localVarCollection : public AnnotationContainer<localVar *> {
54   
55   std::vector<localVar *> localVars;
56   
57   SYMTAB_EXPORT bool addItem_impl(localVar *);
58 public:
59   SYMTAB_EXPORT localVarCollection(){}
60   SYMTAB_EXPORT ~localVarCollection();
61
62   SYMTAB_EXPORT void addLocalVar(localVar * var);
63   SYMTAB_EXPORT localVar * findLocalVar(std::string &name);
64   SYMTAB_EXPORT std::vector<localVar *> *getAllVars();  
65
66   SYMTAB_EXPORT Serializable *ac_serialize_impl(SerializerBase *, const char * = "localVarCollection") THROW_SPEC (SerializerError);
67 };
68   
69
70
71 /*
72  * Due to DWARF weirdness, this can be shared between multiple BPatch_modules.
73  * So we reference-count to make life easier.
74  */
75 class typeCollection : public Serializable//, public AnnotatableSparse 
76 {
77     friend class Symtab;
78     friend class Object;
79     friend class Module;
80         friend class Type;
81
82     dyn_hash_map<std::string, Type *> typesByName;
83     dyn_hash_map<std::string, Type *> globalVarsByName;
84     dyn_hash_map<int, Type *> typesByID;
85
86
87     // DWARF:
88     /* Cache type collections on a per-image basis.  (Since
89        BPatch_functions are solitons, we don't have to cache them.) */
90     static dyn_hash_map< void *, typeCollection * > fileToTypesMap;
91         //static dyn_hash_map<int, std::vector<std::pair<dataClass, Type **> > > deferred_lookups;
92         static bool doDeferredLookups(typeCollection *);
93
94     // DWARF...
95     bool dwarfParsed_;
96
97         SYMTAB_EXPORT Serializable *serialize_impl(SerializerBase *, const char * = "typeCollection") THROW_SPEC (SerializerError);
98         public:
99     SYMTAB_EXPORT typeCollection();
100     SYMTAB_EXPORT ~typeCollection();
101 public:
102         static void addDeferredLookup(int, dataClass, Type **);
103
104     SYMTAB_EXPORT static typeCollection *getModTypeCollection(Module *mod);
105 #if 0
106     SYMTAB_EXPORT static typeCollection *getGlobalTypeCollection();
107     SYMTAB_EXPORT static void freeTypeCollection(typeCollection *tc);
108 #endif
109
110     // DWARF...
111     SYMTAB_EXPORT bool dwarfParsed() { return dwarfParsed_; }
112     SYMTAB_EXPORT void setDwarfParsed() { dwarfParsed_ = true; }
113
114     SYMTAB_EXPORT Type  *findType(std::string name);
115     SYMTAB_EXPORT Type  *findType(const int ID);
116     SYMTAB_EXPORT Type  *findTypeLocal(std::string name);
117     SYMTAB_EXPORT Type  *findTypeLocal(const int ID);
118     SYMTAB_EXPORT void  addType(Type *type);
119     SYMTAB_EXPORT void        addGlobalVariable(std::string &name, Type *type);
120
121     /* Some debug formats allow forward references.  Rather than
122        fill in forward in a second pass, generate placeholder
123        types, and fill them in as we go.  Because we require
124        One True Pointer for each type (in parseStab.C), when
125        updating a type, return that One True Pointer. */
126     SYMTAB_EXPORT Type * findOrCreateType( const int ID );
127     template<class T>
128     SYMTAB_EXPORT T* addOrUpdateType(T* type);
129
130     SYMTAB_EXPORT Type *findVariableType(std::string &name);
131
132     SYMTAB_EXPORT std::vector<Type *> *getAllTypes();
133     SYMTAB_EXPORT std::vector<std::pair<std::string, Type *> > *getAllGlobalVariables();
134     SYMTAB_EXPORT void clearNumberedTypes();
135 };
136
137 /*
138  * This class defines the collection for the built-in Types
139  * gnu ( and AIX??) use negative numbers to define other types
140  * in terms of these built-in types.
141  * This collection is global and built in the BPatch_image constructor.
142  * This means that only one collection of built-in types is made
143  * per image.  jdd 4/21/99
144  *
145  */
146
147 class SYMTAB_EXPORT builtInTypeCollection {
148    
149     dyn_hash_map<std::string, Type *> builtInTypesByName;
150     dyn_hash_map<int, Type *> builtInTypesByID;
151 public:
152
153     builtInTypeCollection();
154     ~builtInTypeCollection();
155
156     Type        *findBuiltInType(std::string &name);
157     Type        *findBuiltInType(const int ID);
158     void        addBuiltInType(Type *type);
159     std::vector<Type *> *getAllBuiltInTypes();
160    
161 };
162
163 }// namespace SymtabAPI
164 }// namespace Dyninst
165
166 #endif /* _Collections_h_ */
167
168
169