OSDN Git Service

2009-08-26 Jonathan Wakely <jwakely.gcc@gmail.com>
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / testsuite / util / testsuite_abi.cc
1 // -*- C++ -*-
2
3 // Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU General Public License as
7 // published by the Free Software Foundation; either version 3, or (at
8 // your option) any later version.
9
10 // This library is distributed in the hope that it will be useful, but
11 // WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 // General Public License for more details.
14
15 // You should have received a copy of the GNU General Public License
16 // along with this library; see the file COPYING3.  If not see
17 // <http://www.gnu.org/licenses/>.
18
19
20 // Benjamin Kosnik  <bkoz@redhat.com>
21
22 #include "testsuite_abi.h"
23 #include <cstdlib>
24 #include <sstream>
25 #include <fstream>
26 #include <iostream>
27 #include <vector>
28 #include <algorithm>
29
30 using namespace std;
31
32 void 
33 symbol::init(string& data)
34 {
35   const char delim = ':';
36   const char version_delim = '@';
37   const string::size_type npos = string::npos;
38   string::size_type n = 0;
39
40   // Set the type.
41   if (data.find("FUNC") == 0)
42     type = symbol::function;
43   else if (data.find("OBJECT") == 0)
44     type = symbol::object;
45
46   n = data.find_first_of(delim);
47   if (n != npos)
48     data.erase(data.begin(), data.begin() + n + 1);
49
50   // Iff object, get size info.
51   if (type == symbol::object)
52     {
53       n = data.find_first_of(delim);
54       if (n != npos)
55         {
56           string objectsize(data.begin(), data.begin() + n);
57           istringstream iss(objectsize);
58           int x;
59           iss >> x;
60           if (!iss.fail())
61             size = x;
62           data.erase(data.begin(), data.begin() + n + 1);
63         }
64     }
65
66   // Set the name and raw_name.
67   raw_name = string(data.begin(), data.end());
68   n = data.find_first_of(version_delim);
69   if (n != npos)
70     {
71       // Found version string.
72       name = string(data.begin(), data.begin() + n);
73       n = data.find_last_of(version_delim);
74       data.erase(data.begin(), data.begin() + n + 1);
75
76       // Set version name.
77       version_name = data;
78     }
79   else
80     {
81       // No versioning info.
82       name = string(data.begin(), data.end());
83       version_status = symbol::none;
84     }
85
86   // Set the demangled name.
87   demangled_name = demangle(name);
88 }
89
90 void
91 symbol::print() const
92 {
93   const char tab = '\t';
94   cout << name << endl;
95
96   if (demangled_name != name)
97     cout << demangled_name << endl;
98
99   string vers;
100   switch (version_status)
101     {
102     case none:
103       vers = "none";
104       break;
105     case compatible:
106       vers = "compatible";
107       break;
108     case incompatible:
109       vers = "incompatible";
110       break;
111      case unversioned:
112       vers = "unversioned";
113       break;
114    default:
115       vers = "<default>";
116     }
117   cout << "version status: " << vers << endl;
118
119   if (version_name.size() 
120       && (version_status == compatible || version_status == incompatible))
121     cout << version_name << endl;  
122
123   string type_string;
124   switch (type)
125     {
126     case function:
127       type_string = "function";
128       break;
129     case object:
130       type_string = "object";
131       break;
132     case uncategorized:
133       type_string = "uncategorized";
134       break;
135     default:
136       type_string = "<default>";
137     }
138   cout << "type: " << type_string << endl;
139   
140   if (type == object)
141     cout << "type size: " << size << endl;
142
143   string status_string;
144   switch (status)
145     {
146     case added:
147       status_string = "added";
148       break;
149     case subtracted:
150       status_string = "subtracted";
151       break;
152     case undesignated:
153       status_string = "undesignated";
154       break;
155     default:
156       status_string = "<default>";
157     }
158   cout << "status: " << status_string << endl;
159
160   cout << endl;
161 }
162
163
164 bool
165 check_version(symbol& test, bool added)
166 {
167   // Construct list of compatible versions.
168   typedef std::vector<std::string> compat_list;
169   static compat_list known_versions;
170   if (known_versions.empty())
171     {
172       // NB: First version here must be the default version for this
173       // version of DT_SONAME.
174       known_versions.push_back("GLIBCXX_3.4");
175       known_versions.push_back("GLIBCXX_3.4.1");
176       known_versions.push_back("GLIBCXX_3.4.2");
177       known_versions.push_back("GLIBCXX_3.4.3");
178       known_versions.push_back("GLIBCXX_3.4.4"); 
179       known_versions.push_back("GLIBCXX_3.4.5");
180       known_versions.push_back("GLIBCXX_3.4.6");
181       known_versions.push_back("GLIBCXX_3.4.7");
182       known_versions.push_back("GLIBCXX_3.4.8");
183       known_versions.push_back("GLIBCXX_3.4.9");
184       known_versions.push_back("GLIBCXX_3.4.10");
185       known_versions.push_back("GLIBCXX_3.4.11");
186       known_versions.push_back("GLIBCXX_3.4.12");
187       known_versions.push_back("GLIBCXX_3.4.13");
188       known_versions.push_back("GLIBCXX_3.4.14");
189       known_versions.push_back("GLIBCXX_LDBL_3.4");
190       known_versions.push_back("GLIBCXX_LDBL_3.4.7");
191       known_versions.push_back("GLIBCXX_LDBL_3.4.10");
192       known_versions.push_back("CXXABI_1.3");
193       known_versions.push_back("CXXABI_1.3.1");
194       known_versions.push_back("CXXABI_1.3.2");
195       known_versions.push_back("CXXABI_1.3.3");
196       known_versions.push_back("CXXABI_LDBL_1.3");
197     }
198   compat_list::iterator begin = known_versions.begin();
199   compat_list::iterator end = known_versions.end();
200
201   // Check for compatible version.
202   if (test.version_name.size())
203     {
204       compat_list::iterator it1 = find(begin, end, test.version_name);
205       compat_list::iterator it2 = find(begin, end, test.name);
206       if (it1 != end)
207         test.version_status = symbol::compatible;
208       else
209         test.version_status = symbol::incompatible;
210       
211       // Check that added symbols aren't added in the base version.
212       if (added && test.version_name == known_versions[0])
213         test.version_status = symbol::incompatible;
214       
215       // Check that long double compatibility symbols demangled as
216       // __float128 are put into some _LDBL_ version name.
217       if (added && test.demangled_name.find("__float128") != std::string::npos)
218         {
219           // Has to be in _LDBL_ version name.
220           if (test.version_name.find("_LDBL_") == std::string::npos)
221             test.version_status = symbol::incompatible;
222         }
223
224       // Check for weak label.
225       if (it1 == end && it2 == end)
226         test.version_status = symbol::incompatible;
227       
228       // Check that 
229       // GLIBCXX_3.4
230       // GLIBCXX_3.4.5
231       // version as compatible
232       // XXX
233     }
234   else
235     {
236       if (added)
237         {
238           // New version labels are ok. The rest are not.
239           compat_list::iterator it2 = find(begin, end, test.name);
240           if (it2 != end)
241             test.version_status = symbol::compatible;
242           else
243             test.version_status = symbol::incompatible;
244         }
245     }
246   return test.version_status == symbol::compatible;
247 }
248
249 bool 
250 check_compatible(symbol& lhs, symbol& rhs, bool verbose)
251 {
252   bool ret = true;
253   const char tab = '\t';
254
255   // Check to see if symbol_objects are compatible.
256   if (lhs.type != rhs.type)
257     {
258       ret = false;
259       if (verbose)
260         cout << tab << "incompatible types" << endl;
261     }
262   
263   if (lhs.name != rhs.name)
264     {
265       ret = false;
266       if (verbose)
267         cout << tab << "incompatible names" << endl;
268     }
269
270   if (lhs.size != rhs.size)
271     {
272       ret = false;
273       if (verbose)
274         {
275           cout << tab << "incompatible sizes" << endl;
276           cout << tab << lhs.size << endl;
277           cout << tab << rhs.size << endl;
278         }
279     }
280
281   if (lhs.version_name != rhs.version_name 
282       && !check_version(lhs) && !check_version(rhs))
283     {
284       ret = false;
285       if (verbose)
286         {
287           cout << tab << "incompatible versions" << endl;
288           cout << tab << lhs.version_name << endl;
289           cout << tab << rhs.version_name << endl;
290         }
291     }
292
293   if (verbose)
294     cout << endl;
295
296   return ret;
297 }
298
299
300 inline bool
301 has_symbol(const string& name, const symbols& s) throw()
302 { return s.find(name) != s.end(); }
303
304 const symbol&
305 get_symbol(const string& name, const symbols& s)
306 {
307   symbols::const_iterator i = s.find(name);
308   if (i != s.end())
309     {
310       return i->second;
311     }
312   else
313     {
314       ostringstream os;
315       os << "get_symbol failed for symbol " << name;
316       __throw_logic_error(os.str().c_str());
317     }
318 }
319
320 void 
321 examine_symbol(const char* name, const char* file)
322 {
323   try
324     {
325       symbols s = create_symbols(file);
326       const symbol& sym = get_symbol(name, s);
327       sym.print();
328     }
329   catch(...)
330     { __throw_exception_again; }
331 }
332
333 int
334 compare_symbols(const char* baseline_file, const char* test_file, 
335                 bool verbose)
336 {
337   // Input both lists of symbols into container.
338   symbols baseline = create_symbols(baseline_file);
339   symbols test = create_symbols(test_file);
340
341   //  Sanity check results.
342   if (!baseline.size() || !test.size())
343     {
344       cerr << "Problems parsing the list of exported symbols." << endl;
345       exit(2);
346     }
347
348   // Check to see if any long double compatibility symbols are produced.
349   bool ld_version_found(false);
350   symbols::iterator li(test.begin());
351   while (!ld_version_found && li != test.end())
352     {
353       if (li->second.version_name.find("_LDBL_") != std::string::npos)
354         ld_version_found = true;
355       ++li;
356     }
357
358   // Sort out names.
359   // Assuming all baseline names and test names are both unique w/ no
360   // duplicates.
361   //
362   // The names added to missing_names are baseline names not found in
363   // test names 
364   // -> symbols that have been deleted.
365   //
366   // The names added to added_names are test names not in
367   // baseline names
368   // -> symbols that have been added.
369   typedef std::vector<std::string> symbol_names;
370   symbol_names shared_names;
371   symbol_names missing_names;
372   symbol_names added_names;
373   for (li = test.begin(); li != test.end(); ++li)
374     added_names.push_back(li->first);
375
376   for (symbols::iterator i = baseline.begin(); i != baseline.end(); ++i)
377     {
378       string name(i->first);
379       symbol_names::iterator end = added_names.end();
380       symbol_names::iterator it = find(added_names.begin(), end, name);
381       if (it != end)
382         {
383           // Found.
384           shared_names.push_back(name);
385           added_names.erase(it);
386         }
387        else
388         {
389           // Iff no test long double compatibility symbols at all and the symbol
390           // missing is a baseline long double compatibility symbol, skip.
391           string version_name(i->second.version_name);
392           bool base_ld(version_name.find("_LDBL_") != std::string::npos);
393           if (!base_ld || base_ld && ld_version_found)
394             missing_names.push_back(name);
395         }
396     }
397
398   // Fill out list of incompatible symbols.
399   typedef pair<symbol, symbol> symbol_pair;
400   vector<symbol_pair> incompatible;
401
402   // Check missing names for compatibility.
403   for (size_t j = 0; j < missing_names.size(); ++j)
404     {
405       symbol& sbase = baseline[missing_names[j]];
406       sbase.status = symbol::subtracted;
407       incompatible.push_back(symbol_pair(sbase, sbase));
408     }
409
410   // Check shared names for compatibility.
411   const symbol_names::size_type shared_size = shared_names.size();
412   for (size_t k = 0; k < shared_size; ++k)
413     {
414       symbol& sbase = baseline[shared_names[k]];
415       symbol& stest = test[shared_names[k]];
416       stest.status = symbol::existing;
417       if (!check_compatible(sbase, stest))
418         incompatible.push_back(symbol_pair(sbase, stest));
419     }
420
421   // Check added names for compatibility.
422   const symbol_names::size_type added_size = added_names.size();
423   for (size_t l = 0; l < added_size; ++l)
424     {
425       symbol& stest = test[added_names[l]];
426       stest.status = symbol::added;
427       if (!check_version(stest, true))
428         incompatible.push_back(symbol_pair(stest, stest));
429     }
430
431   // Report results.
432   if (verbose && added_names.size())
433     {
434       cout << endl << added_names.size() << " added symbols " << endl;
435       for (size_t j = 0; j < added_names.size() ; ++j)
436         {
437           cout << j << endl;
438           test[added_names[j]].print();
439         }
440     }
441   
442   if (verbose && missing_names.size())
443     {
444       cout << endl << missing_names.size() << " missing symbols " << endl;
445       for (size_t j = 0; j < missing_names.size() ; ++j)
446         {
447           cout << j << endl;
448           baseline[missing_names[j]].print();
449         }
450     }
451   
452   if (verbose && incompatible.size())
453     {
454       cout << endl << incompatible.size() << " incompatible symbols " << endl;
455       for (size_t j = 0; j < incompatible.size() ; ++j)
456         {
457           // First, print index.
458           cout << j << endl;
459
460           // Second, report name.
461           symbol& sbase = incompatible[j].first;
462           symbol& stest = incompatible[j].second;
463           stest.print();
464           
465           // Second, report reason or reasons incompatible.
466           check_compatible(sbase, stest, true);
467         }
468     }
469   
470   cout << "\n\t\t=== libstdc++-v3 check-abi Summary ===" << endl;
471   cout << endl;
472   cout << "# of added symbols:\t\t " << added_names.size() << endl;
473   cout << "# of missing symbols:\t\t " << missing_names.size() << endl;
474   cout << "# of incompatible symbols:\t " << incompatible.size() << endl;
475   cout << endl;
476   cout << "using: " << baseline_file << endl;
477
478   return !(missing_names.size() || incompatible.size());
479 }
480
481
482 symbols
483 create_symbols(const char* file)
484 {
485   symbols s;
486   ifstream ifs(file);
487   if (ifs.is_open())
488     {
489       // Organize file data into an associated container (symbols) of symbol
490       // objects mapped to mangled names without versioning
491       // information.
492       const string empty;
493       string line = empty;
494       while (getline(ifs, line).good())
495         {
496           symbol tmp;
497           tmp.init(line);
498           s[tmp.name] = tmp;
499           line = empty;
500         }
501     }
502   else
503     {
504       ostringstream os;
505       os << "create_symbols failed for file " << file;
506       __throw_runtime_error(os.str().c_str());
507     }
508   return s;
509 }
510
511
512 const char*
513 demangle(const std::string& mangled)
514 {
515   const char* name;
516   if (mangled[0] != '_' || mangled[1] != 'Z')
517     {
518       // This is not a mangled symbol, thus has "C" linkage.
519       name = mangled.c_str();
520     }
521   else
522     {
523       // Use __cxa_demangle to demangle.
524       int status = 0;
525       name = abi::__cxa_demangle(mangled.c_str(), 0, 0, &status);
526       if (!name)
527         {
528           switch (status)
529             {
530             case 0:
531               name = "error code = 0: success";
532               break;
533             case -1:
534               name = "error code = -1: memory allocation failure";
535               break;
536             case -2:
537               name = "error code = -2: invalid mangled name";
538               break;
539             case -3:
540               name = "error code = -3: invalid arguments";
541               break;
542             default:
543               name = "error code unknown - who knows what happened";
544             }
545         }
546     }
547   return name;
548 }
549