windows build fixes and some more work on symtab serialization
[dyninst.git] / symtabAPI / h / Variable.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 #if !defined(_Variable_h_)
33 #define _Variable_h_
34
35 #include "Annotatable.h"
36 #include "Serialization.h"
37 #include "Symtab.h"
38 #include "Aggregate.h"
39
40 //class Dyninst::SymtabAPI::Variable;
41 SYMTAB_EXPORT std::ostream &operator<<(std::ostream &os, const Dyninst::SymtabAPI::Variable &);
42
43 namespace Dyninst{
44 namespace SymtabAPI {
45
46 /*
47  * storageClass: Encodes how a variable is stored.
48  *
49  * storageAddr           - Absolute address of variable.
50  * storageReg            - Register which holds variable value.
51  * storageRegOffset      - Address of variable = $reg + address.
52  */
53
54 typedef enum {
55         storageAddr,
56         storageReg,
57         storageRegOffset
58 } storageClass;
59
60 const char *storageClass2Str(storageClass sc);
61
62 /*
63  * storageRefClass: Encodes if a variable can be accessed through a register/address.
64  *
65  * storageRef        - There is a pointer to variable.
66  * storageNoRef      - No reference. Value can be obtained using storageClass.
67  */
68 typedef enum {
69         storageRef,
70         storageNoRef
71 } storageRefClass;
72
73 const char *storageRefClass2Str(storageRefClass sc);
74
75 //location for a variable
76 class VariableLocation : public Serializable {
77         public:
78         storageClass stClass;
79         storageRefClass refClass;
80         int reg;
81         long frameOffset;
82         Address lowPC;
83         Address hiPC;
84         SYMTAB_EXPORT bool operator==(const VariableLocation &);
85         SYMTAB_EXPORT void serialize(SerializerBase *, const char *tag = "VariableLocation") THROW_SPEC (SerializerError);
86 };
87
88 class SYMTAB_EXPORT localVar
89 {
90         friend class typeCommon;
91         friend class localVarCollection;
92
93         std::string name_;
94         Type *type_;
95         std::string fileName_;
96         int lineNum_;
97         std::vector<VariableLocation> *locs_;
98         void *upPtr_;
99
100         // scope_t scope;
101
102         public:
103         localVar() {}
104         //  Internal use only
105         localVar(std::string name,  Type *typ, std::string fileName, int lineNum, std::vector<VariableLocation> *locs = NULL);
106         // Copy constructor
107         localVar(localVar &lvar);
108         bool addLocation(VariableLocation *location);
109         bool setLocation(std::vector<VariableLocation> &locs);
110         ~localVar();
111         void fixupUnknown(Module *);
112         public:
113         //  end of functions for internal use only
114         std::string &getName();
115         Type *getType();
116         bool setType(Type *newType);
117         int  getLineNum();
118         std::string &getFileName();
119         std::vector<VariableLocation> *getLocationLists();
120
121         void *getUpPtr() const;
122         bool setUpPtr(void *);
123 };
124
125 class Symbol;
126 class Symtab;
127 class Aggregate;
128
129 class Variable : public Aggregate, public Serializable {
130         friend class Symtab;
131         friend std::ostream &::operator<<(std::ostream &os, const Dyninst::SymtabAPI::Variable &);
132
133         private:
134    SYMTAB_EXPORT Variable(Symbol *sym);
135    SYMTAB_EXPORT static Variable *createVariable(Symbol *sym);
136    
137  public:
138    SYMTAB_EXPORT Variable();
139     /* Symbol management */
140     SYMTAB_EXPORT bool removeSymbol(Symbol *sym);      
141
142    SYMTAB_EXPORT void setType(Type *type);
143    SYMTAB_EXPORT Type *getType();
144
145    SYMTAB_EXPORT 
146    void serialize(SerializerBase *sb, const char *tag = "Variable") THROW_SPEC (SerializerError);
147    SYMTAB_EXPORT bool operator==(const Variable &v);
148
149  private:
150
151    Type *type_;
152 };
153
154
155 }
156 }
157
158 #endif