Fixes for accessing local variable via StackwalkerAPI
[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 //Use mr_reg instead of reg for new code.  reg left in for backwards
77 // compatibility.
78 class VariableLocation : public Serializable {
79         public:
80         storageClass stClass;
81         storageRefClass refClass;
82         int reg;
83    MachRegister mr_reg;
84         long frameOffset;
85         Address lowPC;
86         Address hiPC;
87         SYMTAB_EXPORT bool operator==(const VariableLocation &);
88         SYMTAB_EXPORT Serializable * serialize_impl(SerializerBase *, 
89                         const char *tag = "VariableLocation") THROW_SPEC (SerializerError);
90 };
91
92
93 class Symbol;
94 class Symtab;
95 class Aggregate;
96 class Function;
97
98 class Variable : public Aggregate, public Serializable, public AnnotatableSparse {
99         friend class Symtab;
100         friend std::ostream &::operator<<(std::ostream &os, const Dyninst::SymtabAPI::Variable &);
101
102         private:
103    SYMTAB_EXPORT Variable(Symbol *sym);
104    SYMTAB_EXPORT static Variable *createVariable(Symbol *sym);
105    
106  public:
107    SYMTAB_EXPORT Variable();
108     /* Symbol management */
109     SYMTAB_EXPORT bool removeSymbol(Symbol *sym);      
110
111    SYMTAB_EXPORT void setType(Type *type);
112    SYMTAB_EXPORT Type *getType();
113
114    SYMTAB_EXPORT Serializable *serialize_impl(SerializerBase *sb, 
115                    const char *tag = "Variable") THROW_SPEC (SerializerError);
116    SYMTAB_EXPORT bool operator==(const Variable &v);
117
118  private:
119
120    Type *type_;
121 };
122
123 class localVar : public Serializable, public AnnotatableSparse
124 {
125         friend class typeCommon;
126         friend class localVarCollection;
127
128         std::string name_;
129         Type *type_;
130         std::string fileName_;
131         int lineNum_;
132    Function *func_;
133         std::vector<VariableLocation> locs_;
134
135         // scope_t scope;
136
137         public:
138         SYMTAB_EXPORT localVar() {}
139         //  Internal use only
140         localVar(std::string name,  Type *typ, std::string fileName, 
141             int lineNum, Function *f, 
142             std::vector<VariableLocation> *locs = NULL);
143             
144         // Copy constructor
145         localVar(localVar &lvar);
146         bool addLocation(VariableLocation &location);
147         SYMTAB_EXPORT ~localVar();
148         SYMTAB_EXPORT void fixupUnknown(Module *);
149
150         public:
151         //  end of functions for internal use only
152         SYMTAB_EXPORT std::string &getName();
153         SYMTAB_EXPORT Type *getType();
154         SYMTAB_EXPORT bool setType(Type *newType);
155         SYMTAB_EXPORT int  getLineNum();
156         SYMTAB_EXPORT std::string &getFileName();
157         SYMTAB_EXPORT std::vector<VariableLocation> &getLocationLists();
158         SYMTAB_EXPORT bool operator==(const localVar &l);
159         SYMTAB_EXPORT Serializable *serialize_impl(SerializerBase *, 
160                         const char * = "localVar") THROW_SPEC(SerializerError);
161 };
162
163 }
164 }
165
166 #endif