Temporary checkpoint
[dyninst.git] / symtabAPI / src / Variable.C
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 // $Id: Object.C,v 1.31 2008/11/03 15:19:25 jaw Exp $
33
34 #include "Annotatable.h"
35 #include "common/h/serialize.h"
36
37 #include "Symtab.h"
38 #include "symutil.h"
39 #include "Module.h"
40 #include "Collections.h"
41 #include "Variable.h"
42
43 #include "symtabAPI/src/Object.h"
44
45 #include <iostream>
46
47 using namespace std;
48 using namespace Dyninst;
49 using namespace Dyninst::SymtabAPI;
50
51
52
53 Variable::Variable()
54     : address_(0), module_(NULL) {}
55
56 Variable *Variable::createVariable(Symbol *sym) {
57     Variable *var = new Variable();
58     var->addSymbol(sym);
59     return var;
60 }
61
62 Offset Variable::getAddress() const {
63     return address_;
64 }
65
66 Module *Variable::getModule() const {
67     return module_;
68 }
69
70 bool Variable::addSymbol(Symbol *sym) {
71     if (address_ == 0) 
72         address_ = sym->getAddr();
73     else
74         assert(address_ == sym->getAddr());
75
76     // We keep a "primary" module, which is defined as "anything not DEFAULT_MODULE".
77     if (module_ == NULL) {
78         module_ = sym->getModule();
79     }
80     else if (module_->fileName() == "DEFAULT_MODULE") {
81         module_ = sym->getModule();
82     }
83     // else keep current module.
84
85     symbols_.push_back(sym);
86
87     // We need to add the symbol names (if they aren't there already)
88     // We can have multiple identical names - for example, there are
89     // often two symbols for main (static and dynamic symbol table)
90     
91     bool found = false;
92     for (unsigned j = 0; j < mangledNames_.size(); j++) {
93         if (sym->getMangledName() == mangledNames_[j]) {
94             found = true;
95             break;
96         }
97     }
98     if (!found) mangledNames_.push_back(sym->getMangledName());
99
100     found = false;
101
102     for (unsigned j = 0; j < prettyNames_.size(); j++) {
103         if (sym->getPrettyName() == prettyNames_[j]) {
104             found = true;
105             break;
106         }
107     }
108     if (!found) prettyNames_.push_back(sym->getPrettyName());
109
110     found = false;
111     for (unsigned j = 0; j < typedNames_.size(); j++) {
112         if (sym->getTypedName() == typedNames_[j]) {
113             found = true;
114             break;
115         }
116     }
117     if (!found) typedNames_.push_back(sym->getTypedName());;
118
119     return true;
120 }
121
122 bool Variable::removeSymbol(Symbol *sym) {
123     std::vector<Symbol *>::iterator iter;
124     for (iter = symbols_.begin(); iter != symbols_.end(); iter++) {
125         if (*iter == sym) {
126             symbols_.erase(iter);
127             return true;
128         }
129     }
130     return false;
131 }
132
133 bool Variable::getAllSymbols(std::vector<Symbol *> &syms) const {
134     syms = symbols_;
135     return true;
136 }
137
138 Symbol * Variable::getFirstSymbol() const
139 {
140     assert( symbols_.size()>0 );
141     return symbols_[0];
142 }
143
144 SYMTABEXPORT bool Variable::addMangledName(string name, bool isPrimary) 
145 {
146     // Check to see if we're duplicating
147     for (unsigned i = 0; i < mangledNames_.size(); i++) {
148         if (mangledNames_[i] == name)
149             return false;
150     }
151
152     if (isPrimary) {
153         std::vector<std::string>::iterator iter = mangledNames_.begin();
154         mangledNames_.insert(iter, name);
155     }
156     else
157         mangledNames_.push_back(name);
158
159     /*
160       // Need to create symbol for this new name
161       if (getModule()->exec()) {
162       getModule()->exec()->updateIndices(this, name, Symtab::mangledName);
163       }
164     */
165     
166     return true;
167 }                                                                                                                                       
168
169 SYMTABEXPORT bool Variable::addPrettyName(string name, bool isPrimary) 
170 {
171     // Check to see if we're duplicating
172     for (unsigned i = 0; i < prettyNames_.size(); i++) {
173         if (prettyNames_[i] == name)
174             return false;
175     }
176
177     if (isPrimary) {
178         std::vector<std::string>::iterator iter = prettyNames_.begin();
179         prettyNames_.insert(iter, name);
180     }
181     else
182         prettyNames_.push_back(name);
183
184     /*
185       // Need to create symbol for this new name
186     if (getModule()->exec()) {
187         getModule()->exec()->updateIndices(this, name, Symtab::prettyName);
188     }
189     */    
190     return true;
191 }                                                                                                                                       
192
193 SYMTABEXPORT bool Variable::addTypedName(string name, bool isPrimary) 
194 {
195     // Check to see if we're duplicating
196     for (unsigned i = 0; i < typedNames_.size(); i++) {
197         if (typedNames_[i] == name)
198             return false;
199     }
200
201     if (isPrimary) {
202         std::vector<std::string>::iterator iter = typedNames_.begin();
203         typedNames_.insert(iter, name);
204     }
205     else
206         typedNames_.push_back(name);
207     /*
208       // Need to create symbol for this new name
209     if (getModule()->exec()) {
210         getModule()->exec()->updateIndices(this, name, Symtab::typedName);
211     }
212     */
213
214     return true;
215 }