symtabAPI/h/Collections.h

   1 /*
   2  * Copyright (c) 1996-2007 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
  37 using namespace std;
  38 namespace Dyninst {
  39
  40 namespace SymtabAPI {
  41
  42 class Module;
  43 class Symtab;
  44
  45 /*
  46  * This class contains a collection of local variables.
  47  * Each function will have one of these objects associated with it.
  48  * This object will store all the local variables within this function.
  49  * Note: This class is unaware of scope.
  50  */
  51 class SYMTAB_EXPORT localVarCollection : public Serializable, public AnnotatableSparse {
  52
  53   dyn_hash_map<std::string, localVar *> localVariablesByName;
  54   vector<localVar *> localVars;
  55
  56 public:
  57   localVarCollection(){}
  58   ~localVarCollection();
  59
  60   void addLocalVar(localVar * var);
  61   localVar * findLocalVar(std::string &name);
  62   vector<localVar *> *getAllVars();
  63
  64   void serialize(SerializerBase *, const char * = "localVarCollection");
  65 };
  66
  67
  68
  69 /*
  70  * Due to DWARF weirdness, this can be shared between multiple BPatch_modules.
  71  * So we reference-count to make life easier.
  72  */
  73 class SYMTAB_EXPORT typeCollection : public Serializable, public AnnotatableSparse {
  74     friend class Symtab;
  75     friend class Object;
  76     friend class Module;
  77     friend class SymtabTranslatorBase;
  78     friend class SymtabTranslatorBin;
  79
  80     dyn_hash_map<std::string, Type *> typesByName;
  81     dyn_hash_map<std::string, Type *> globalVarsByName;
  82     dyn_hash_map<int, Type *> typesByID;
  83
  84     ~typeCollection();
  85
  86     unsigned refcount;
  87     typeCollection();
  88
  89     // DWARF:
  90     /* Cache type collections on a per-image basis.  (Since
  91        BPatch_functions are solitons, we don't have to cache them.) */
  92     static dyn_hash_map< std::string, typeCollection * > fileToTypesMap;
  93
  94     // DWARF...
  95     bool dwarfParsed_;
  96
  97 public:
  98     void serialize(SerializerBase *, const char * = "typeCollection");
  99     static typeCollection *getGlobalTypeCollection();
 100     static typeCollection *getModTypeCollection(Module *mod);
 101     static void freeTypeCollection(typeCollection *tc);
 102
 103     // DWARF...
 104     bool dwarfParsed() { return dwarfParsed_; }
 105     void setDwarfParsed() { dwarfParsed_ = true; }
 106
 107     Type        *findType(std::string name);
 108     Type        *findType(const int ID);
 109     Type        *findTypeLocal(std::string name);
 110     Type        *findTypeLocal(const int ID);
 111     void        addType(Type *type);
 112     void        addGlobalVariable(std::string &name, Type *type);
 113
 114     /* Some debug formats allow forward references.  Rather than
 115        fill in forward in a second pass, generate placeholder
 116        types, and fill them in as we go.  Because we require
 117        One True Pointer for each type (in parseStab.C), when
 118        updating a type, return that One True Pointer. */
 119     Type * findOrCreateType( const int ID );
 120     template<class T>
 121     T* addOrUpdateType(T* type);
 122
 123     Type *findVariableType(std::string &name);
 124
 125     std::vector<Type *> *getAllTypes();
 126     std::vector<std::pair<std::string, Type *> > *getAllGlobalVariables();
 127     void clearNumberedTypes();
 128 };
 129
 130 /*
 131  * This class defines the collection for the built-in Types
 132  * gnu ( and AIX??) use negative numbers to define other types
 133  * in terms of these built-in types.
 134  * This collection is global and built in the BPatch_image constructor.
 135  * This means that only one collection of built-in types is made
 136  * per image.  jdd 4/21/99
 137  *
 138  */
 139
 140 class SYMTAB_EXPORT builtInTypeCollection {
 141
 142     dyn_hash_map<std::string, Type *> builtInTypesByName;
 143     dyn_hash_map<int, Type *> builtInTypesByID;
 144 public:
 145
 146     builtInTypeCollection();
 147     ~builtInTypeCollection();
 148
 149     Type        *findBuiltInType(std::string &name);
 150     Type        *findBuiltInType(const int ID);
 151     void        addBuiltInType(Type *type);
 152     std::vector<Type *> *getAllBuiltInTypes();
 153
 154 };
 155
 156 }// namespace SymtabAPI
 157 }// namespace Dyninst
 158
 159 #endif /* _Collections_h_ */
 160
 161
 162