windows build fixes and some more work on symtab serialization
[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 #include "Aggregate.h"
43
44 #include "symtabAPI/src/Object.h"
45
46 #include <iostream>
47
48 using namespace std;
49 using namespace Dyninst;
50 using namespace Dyninst::SymtabAPI;
51
52 Variable::Variable(Symbol *sym) :
53     Aggregate(sym),
54     type_(NULL)
55 {
56 }
57
58 Variable::Variable() :
59     Aggregate(),
60     type_(NULL)
61 {
62 }
63 void Variable::setType(Type *type)
64 {
65    type_ = type;
66 }
67
68 Type* Variable::getType()
69 {
70    module_->exec()->parseTypesNow();
71    return type_;
72 }
73
74 void Variable::serialize(SerializerBase *sb, const char *tag) THROW_SPEC (SerializerError)
75 {
76         fprintf(stderr, "%s[%d]:  welcome to Variable::serialize\n", FILE__, __LINE__);
77         if (!sb)
78         {
79                 SER_ERR("bad paramater sb");
80         }
81
82         //  Use typeID as unique identifier
83         unsigned int t_id = type_ ? type_->getID() : (unsigned int) 0xdeadbeef; 
84
85         try 
86         {
87                 ifxml_start_element(sb, tag);
88                 gtranslate(sb, t_id, "typeID");
89                 Aggregate::serialize_aggregate(sb);
90                 ifxml_end_element(sb, tag);
91                 restore_type_by_id(sb, type_, t_id);
92         } 
93         SER_CATCH(tag);
94 }
95
96 std::ostream &operator<<(std::ostream &os, const Dyninst::SymtabAPI::Variable &v)
97 {
98         std::string tname(v.type_ ? v.type_->getName() : "no_type");
99         const Aggregate *ag = dynamic_cast<const Aggregate *>(&v);
100         assert(ag);
101
102         os  << "Variable{"        
103                 << " type=" 
104                 << tname
105             << " ";                                                
106         os  <<  *ag;                                       
107         os  <<  "}";
108         return os;      
109
110 }
111 bool Variable::operator==(const Variable &v)
112 {
113         if (type_ && !v.type_)
114                 return false;
115         if (!type_ && v.type_)
116                 return false;
117         if (type_)
118                 if (type_->getID() != v.type_->getID())
119                 {
120                         return false;
121                 }
122         return ((Aggregate &)(*this)) == ((Aggregate &)v);
123 }
124
125 bool Variable::removeSymbol(Symbol *sym) 
126 {
127     removeSymbolInt(sym);
128     if (symbols_.empty()) {
129         module_->exec()->deleteVariable(this);
130     }
131     return true;
132 }
133
134 namespace Dyninst {
135         namespace SymtabAPI {
136 const char *storageClass2Str(Dyninst::SymtabAPI::storageClass sc) 
137 {
138         switch(sc) {
139                 CASE_RETURN_STR(storageAddr);
140                 CASE_RETURN_STR(storageReg);
141                 CASE_RETURN_STR(storageRegOffset);
142         };
143         return "bad_storage_class";
144 }
145
146 const char *storageRefClass2Str(Dyninst::SymtabAPI::storageRefClass sc) 
147 {
148         switch(sc) {
149                 CASE_RETURN_STR(storageRef);
150                 CASE_RETURN_STR(storageNoRef);
151         };
152         return "bad_storage_class";
153 }
154 }
155 }
156
157 bool VariableLocation::operator==(const VariableLocation &f)
158 {
159         if (stClass != f.stClass) return false;
160         if (refClass != f.refClass) return false;
161         if (reg != f.reg) return false;
162         if (frameOffset != f.frameOffset) return false;
163         if (hiPC != f.hiPC) return false;
164         if (lowPC != f.lowPC) return false;
165         return true;
166 }
167 void VariableLocation::serialize(SerializerBase *sb, const char *tag) THROW_SPEC (SerializerError)
168 {
169         ifxml_start_element(sb, tag);
170         gtranslate(sb, (int &)stClass, "StorageClass");
171         gtranslate(sb, (int &)refClass, "StorageRefClass");
172         gtranslate(sb, reg, "register");
173         gtranslate(sb, frameOffset, "frameOffset");
174         gtranslate(sb, hiPC, "hiPC");
175         gtranslate(sb, lowPC, "lowPC");
176         ifxml_end_element(sb, tag);
177 }