Update copyright to LGPL on all files
[dyninst.git] / symtabAPI / h / Variable.h
1 /*
2  * Copyright (c) 1996-2009 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 Serializable * serialize_impl(SerializerBase *, 
86                         const char *tag = "VariableLocation") THROW_SPEC (SerializerError);
87 };
88
89
90 class Symbol;
91 class Symtab;
92 class Aggregate;
93 class Function;
94
95 class Variable : public Aggregate, public Serializable, public AnnotatableSparse {
96         friend class Symtab;
97         friend std::ostream &::operator<<(std::ostream &os, const Dyninst::SymtabAPI::Variable &);
98
99         private:
100    SYMTAB_EXPORT Variable(Symbol *sym);
101    SYMTAB_EXPORT static Variable *createVariable(Symbol *sym);
102    
103  public:
104    SYMTAB_EXPORT Variable();
105     /* Symbol management */
106     SYMTAB_EXPORT bool removeSymbol(Symbol *sym);      
107
108    SYMTAB_EXPORT void setType(Type *type);
109    SYMTAB_EXPORT Type *getType();
110
111    SYMTAB_EXPORT Serializable *serialize_impl(SerializerBase *sb, 
112                    const char *tag = "Variable") THROW_SPEC (SerializerError);
113    SYMTAB_EXPORT bool operator==(const Variable &v);
114
115  private:
116
117    Type *type_;
118 };
119
120 class localVar : public Serializable, public AnnotatableSparse
121 {
122         friend class typeCommon;
123         friend class localVarCollection;
124
125         std::string name_;
126         Type *type_;
127         std::string fileName_;
128         int lineNum_;
129    Function *func_;
130         std::vector<VariableLocation> locs_;
131
132         // scope_t scope;
133
134         public:
135         SYMTAB_EXPORT localVar() {}
136         //  Internal use only
137         localVar(std::string name,  Type *typ, std::string fileName, 
138             int lineNum, Function *f, 
139             std::vector<VariableLocation> *locs = NULL);
140             
141         // Copy constructor
142         localVar(localVar &lvar);
143         bool addLocation(VariableLocation &location);
144         ~localVar();
145         SYMTAB_EXPORT void fixupUnknown(Module *);
146
147         public:
148         //  end of functions for internal use only
149         SYMTAB_EXPORT std::string &getName();
150         SYMTAB_EXPORT Type *getType();
151         SYMTAB_EXPORT bool setType(Type *newType);
152         SYMTAB_EXPORT int  getLineNum();
153         SYMTAB_EXPORT std::string &getFileName();
154         SYMTAB_EXPORT std::vector<VariableLocation> &getLocationLists();
155         SYMTAB_EXPORT bool operator==(const localVar &l);
156         SYMTAB_EXPORT Serializable *serialize_impl(SerializerBase *, 
157                         const char * = "localVar") THROW_SPEC(SerializerError);
158 };
159
160 }
161 }
162
163 #endif