windows build fixes and some more work on symtab serialization
[dyninst.git] / newtestsuite / src / symtab / test_symtab_ser_funcs.C
1 /*
2  * Copyright (c) 1996-2008 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  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 #include "symtab_comp.h"
43 #include "test_lib.h"
44
45 #include "Symtab.h"
46 #include "Symbol.h"
47 #include "Function.h"
48 #include "Variable.h"
49 #include "Module.h"
50 #include "Region.h"
51 #include "Type.h"
52 #include "Archive.h"
53 #include "Serialization.h"
54
55 using namespace Dyninst;
56 using namespace SymtabAPI;
57
58 #if 0
59 extern SerializerBase *nonpublic_make_bin_symtab_serializer(Symtab *, std::string);
60 extern SerializerBase *nonpublic_make_bin_symtab_deserializer(Symtab *, std::string);
61 extern void nonpublic_free_bin_symtab_serializer(SerializerBase *);
62 #endif
63
64 class test_symtab_ser_funcs_Mutator : public SymtabMutator {
65         std::vector<relocationEntry> relocations;
66         std::vector<ExceptionBlock *> exceptions;
67         std::vector<Type *> *stdtypes;
68         std::vector<Type *> *builtintypes;
69         std::vector<Region *> regions;
70         std::vector<SymtabAPI::Module *> modules;
71         std::vector<SymtabAPI::Function *> functions;
72         std::vector<SymtabAPI::Variable *> variables;
73         std::vector<Symbol *> symbols;
74
75         void parse() throw(LocErr);
76
77         static void variable_report(const Variable &s1, const Variable &s2)
78         {
79                 fprintf(stderr, "%s[%d]:  welcome to variable report\n", FILE__, __LINE__);
80         }
81         static void symbol_report(const Symbol &s1, const Symbol &s2)
82         {
83                 fprintf(stderr, "%s[%d]:  NONEQUAL symbols:\n", FILE__, __LINE__);
84                 fprintf(stderr, "\t%s--%s\n", s1.getModuleName().c_str(), s2.getModuleName().c_str());
85                 fprintf(stderr, "\t%s--%s\n", s1.getMangledName().c_str(), s2.getMangledName().c_str());
86                 fprintf(stderr, "\t%s--%s\n", s1.getPrettyName().c_str(), s2.getPrettyName().c_str());
87                 fprintf(stderr, "\t%s--%s\n", s1.getTypedName().c_str(), s2.getTypedName().c_str());
88                 fprintf(stderr, "\t%d--%d\n", s1.getType(), s2.getType());
89                 fprintf(stderr, "\t%d--%d\n", s1.getLinkage(), s2.getLinkage());
90                 fprintf(stderr, "\t%d--%d\n", s1.getVisibility(), s2.getVisibility());
91                 fprintf(stderr, "\t%d--%d\n", s1.isInDynSymtab(), s2.isInDynSymtab());
92                 fprintf(stderr, "\t%d--%d\n", s1.isAbsolute(), s2.isAbsolute());
93                 fprintf(stderr, "\t%d--%d\n", s1.isFunction(), s2.isFunction());
94                 fprintf(stderr, "\t%d--%d\n", s1.isVariable(), s2.isVariable());
95                 fprintf(stderr, "\t%p--%p\n", s1.getAddr(), s2.getAddr());
96                 fprintf(stderr, "\t%d--%d\n", s1.getSize(), s2.getSize());
97                 fprintf(stderr, "\t%d--%d\n", s1.tag(), s2.tag());
98                 Region *r1 = s1.getSec();
99                 Region *r2 = s2.getSec();
100                 if (r1 && !r2) fprintf(stderr, "%s[%d]:  region discrep\n", FILE__, __LINE__);
101                 if (!r1 && r2) fprintf(stderr, "%s[%d]:  region discrep\n", FILE__, __LINE__);
102                 if (r1)
103                 {
104                         fprintf(stderr, "\t%p--%p\n", r1->getDiskOffset(), r2->getDiskOffset());
105                 }
106         }
107
108         typedef void (*symrep_t)(const Symbol &, const Symbol &);
109         typedef void (*varrep_t)(const Variable &, const Variable &);
110
111         template <class C>
112                 bool serialize_test(Symtab *st, C &control, void (*report)(const C &, const C &) ) throw (LocErr)
113                 {
114                         fprintf(stderr, "%s[%d]: welcome to serialize test for type %s\n",
115                                         FILE__, __LINE__, typeid(C).name());
116
117                         Tempfile tf;
118                 std::string file(tf.getName());
119
120                 SerializerBase *sb_serializer_ptr;
121                 sb_serializer_ptr = nonpublic_make_bin_symtab_serializer(st, file);
122                 assert(sb_serializer_ptr);
123                 SerializerBase &sb_serializer = (SerializerBase &) *sb_serializer_ptr;
124
125                 fprintf(stderr, "%s[%d]:  before serialize\n", FILE__, __LINE__);
126                 Serializable *sable = &control;
127                 sable->serialize(sb_serializer_ptr, NULL);
128                 fprintf(stderr, "%s[%d]:  after serialize\n", FILE__, __LINE__);
129                 fflush(NULL);
130
131                 nonpublic_free_bin_symtab_serializer(sb_serializer_ptr);
132
133
134                 C deserialize_result;
135                 SerializerBase *sb_deserializer_ptr;
136                 sb_deserializer_ptr = nonpublic_make_bin_symtab_deserializer(st, file);
137                 assert(sb_deserializer_ptr);
138                 SerializerBase &sb_deserializer = (SerializerBase &) *sb_deserializer_ptr;
139
140                 fprintf(stderr, "\n\n%s[%d]: about to deserialize\n\n",
141                                 FILE__, __LINE__);
142
143                 deserialize_result.serialize(sb_deserializer_ptr, NULL);
144
145                 nonpublic_free_bin_symtab_serializer(sb_deserializer_ptr);
146
147                 //  First check whether operator== (which must exist) returns equivalence
148
149                 if (!(deserialize_result == control))
150                 {
151                         if (report)
152                                 (*report)(deserialize_result, control);
153 #if 0
154                         if (typeid(C) == typeid(Dyninst::SymtabAPI::Symbol))
155                                 symbol_report(deserialize_result, control);
156 #endif
157                         EFAIL("deserialize failed\n");
158                 }
159
160 #if 0
161                 //  Next (since we can't trust operator==() 100%, do a raw mem compare
162
163                 if (memcmp(&control, &deserialize_result, sizeof(C)))
164                         EFAIL("deserialize and operator== failed\n");
165 #endif
166
167                 fprintf(stderr, "%s[%d]:  deserialize succeeded\n", __FILE__, __LINE__);
168         //  FIXME:  need to catch serializer errors here
169         }
170
171         template <class T>
172         void serialize_test_vector(Symtab *st, std::vector<T> &vec, void (*report)(const T &, const T &) )
173         {
174                 for (unsigned int i = 0; i < vec.size(); ++i)
175                 {
176                         T &t = vec[i];
177                         serialize_test(st, t, report);
178                 }
179         }
180
181         template <class T>
182         void serialize_test_vector(Symtab *st, std::vector<T *> &vec, void (*report)(const T &, const T &) )
183         {
184                 for (unsigned int i = 0; i < vec.size(); ++i)
185                 {
186                         T *t = vec[i];
187                         if (!t)
188                                 EFAIL("null array elem\n");
189                         serialize_test(st, *t, report);
190                 }
191         }
192
193         public:
194
195         test_symtab_ser_funcs_Mutator() { };
196         virtual test_results_t executeTest();
197 };
198
199 extern "C" DLLEXPORT TestMutator* test_symtab_ser_funcs_factory()
200 {
201         return new test_symtab_ser_funcs_Mutator();
202 }
203
204 void test_symtab_ser_funcs_Mutator::parse() throw (LocErr)
205 {
206         bool result = symtab->getFuncBindingTable(relocations);
207
208         if (!result || !relocations.size() )
209                 EFAIL("relocations");
210
211 #if 0
212         //  need to make this a c++ test to get exceptions
213         result = symtab->getAllExceptions(exceptions);
214
215         if (!result || !exceptions.size() )
216                 EFAIL("exceptions");
217 #endif
218
219         result = symtab->getAllRegions(regions);
220
221         if (!result || !regions.size() )
222                 EFAIL("regions");
223
224         result = symtab->getAllModules(modules);
225
226         if (!result || !modules.size() )
227                 EFAIL("modules");
228
229         result = symtab->getAllVariables(variables);
230
231         if (!result || !variables.size() )
232                 EFAIL("variables");
233
234         result = symtab->getAllFunctions(functions);
235
236         if (!result || !functions.size() )
237                 EFAIL("functions");
238
239         result = symtab->getAllDefinedSymbols(symbols);
240
241         if (!result || !symbols.size() )
242                 EFAIL("symbols");
243
244         stdtypes = symtab->getAllstdTypes();
245
246         if (!stdtypes)
247                 EFAIL("stdtypes");
248
249         builtintypes = symtab->getAllbuiltInTypes();
250
251         if (!builtintypes)
252         {
253                 EFAIL("builtintypes");
254         }
255 }
256
257 test_results_t test_symtab_ser_funcs_Mutator::executeTest()
258 {
259         try 
260         {
261                 parse();
262
263                 symrep_t sr = &symbol_report;
264                 varrep_t vr = &variable_report;
265                 fprintf(stderr, "%s[%d]:  about to serialize test for variable:\n", FILE__, __LINE__);
266                 cerr << *variables[0] <<endl;
267                 serialize_test(symtab, *variables[0], &variable_report);
268                 serialize_test(symtab, *symbols[0], &symbol_report);
269                 //serialize_test(symtab, *symbols[0], sr);
270 #if 0
271                 serialize_test_vector(symtab, symbols);
272                 serialize_test_vector(symtab, functions);
273                 serialize_test_vector(symtab, variables);
274                 serialize_test_vector(symtab, exceptions);
275                 serialize_test_vector(symtab, relocations);
276                 serialize_test_vector(symtab, regions);
277                 serialize_test_vector(symtab, modules);
278
279                 serialize_test(symtab, *symtab);
280 #endif
281         }
282         REPORT_EFAIL;
283
284         return PASSED;
285 }