Small ChangeLog tweak.
[official-gcc.git] / libstdc++-v3 / testsuite / util / testsuite_abi.cc
blobee7572ea2444d70c15b528f95dd42f0b1723adcb
1 // -*- C++ -*-
3 // Copyright (C) 2004-2017 Free Software Foundation, Inc.
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.
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.
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/>.
20 // Benjamin Kosnik <bkoz@redhat.com>
22 #include "testsuite_abi.h"
23 #include <cstdlib>
24 #include <sstream>
25 #include <fstream>
26 #include <iostream>
27 #include <vector>
28 #include <algorithm>
30 using namespace std;
32 void
33 symbol::init(string& data)
35 const char delim = ':';
36 const char version_delim = '@';
37 const string::size_type npos = string::npos;
38 string::size_type n = 0;
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 else if (data.find("TLS") == 0)
46 type = symbol::tls;
48 n = data.find_first_of(delim);
49 if (n != npos)
50 data.erase(data.begin(), data.begin() + n + 1);
52 // Iff object or TLS, get size info.
53 if (type == symbol::object || type == symbol::tls)
55 n = data.find_first_of(delim);
56 if (n != npos)
58 string objectsize(data.begin(), data.begin() + n);
59 istringstream iss(objectsize);
60 int x;
61 iss >> x;
62 if (!iss.fail())
63 size = x;
64 data.erase(data.begin(), data.begin() + n + 1);
68 // Set the name and raw_name.
69 raw_name = string(data.begin(), data.end());
70 n = data.find_first_of(version_delim);
71 if (n != npos)
73 // Found version string.
74 name = string(data.begin(), data.begin() + n);
75 n = data.find_last_of(version_delim);
76 data.erase(data.begin(), data.begin() + n + 1);
78 // Set version name.
79 version_name = data;
81 else
83 // No versioning info.
84 name = string(data.begin(), data.end());
85 version_status = symbol::none;
88 // Set the demangled name.
89 demangled_name = demangle(name);
92 void
93 symbol::print() const
95 const char tab = '\t';
96 cout << name << endl;
98 if (demangled_name != name)
99 cout << demangled_name << endl;
101 string vers;
102 switch (version_status)
104 case none:
105 vers = "none";
106 break;
107 case compatible:
108 vers = "compatible";
109 break;
110 case incompatible:
111 vers = "incompatible";
112 break;
113 case unversioned:
114 vers = "unversioned";
115 break;
116 default:
117 vers = "<default>";
119 cout << "version status: " << vers << endl;
121 if (version_name.size()
122 && (version_status == compatible || version_status == incompatible))
123 cout << version_name << endl;
125 string type_string;
126 switch (type)
128 case function:
129 type_string = "function";
130 break;
131 case object:
132 type_string = "object";
133 break;
134 case tls:
135 type_string = "tls";
136 break;
137 case uncategorized:
138 type_string = "uncategorized";
139 break;
140 default:
141 type_string = "<default>";
143 cout << "type: " << type_string << endl;
145 if (type == object || type == tls)
146 cout << "type size: " << size << endl;
148 string status_string;
149 switch (status)
151 case added:
152 status_string = "added";
153 break;
154 case subtracted:
155 status_string = "subtracted";
156 break;
157 case undesignated:
158 status_string = "undesignated";
159 break;
160 default:
161 status_string = "<default>";
163 cout << "status: " << status_string << endl;
165 cout << endl;
169 bool
170 check_version(symbol& test, bool added)
172 // Construct list of compatible versions.
173 typedef std::vector<std::string> compat_list;
174 static compat_list known_versions;
175 if (known_versions.empty())
177 // NB: First version here must be the default version for this
178 // version of DT_SONAME.
179 known_versions.push_back("GLIBCXX_3.4");
180 known_versions.push_back("GLIBCXX_LDBL_3.4");
181 known_versions.push_back("GLIBCXX_3.4.1");
182 known_versions.push_back("GLIBCXX_3.4.2");
183 known_versions.push_back("GLIBCXX_3.4.3");
184 known_versions.push_back("GLIBCXX_3.4.4");
185 known_versions.push_back("GLIBCXX_3.4.5");
186 known_versions.push_back("GLIBCXX_3.4.6");
187 known_versions.push_back("GLIBCXX_3.4.7");
188 known_versions.push_back("GLIBCXX_LDBL_3.4.7");
189 known_versions.push_back("GLIBCXX_3.4.8");
190 known_versions.push_back("GLIBCXX_3.4.9");
191 known_versions.push_back("GLIBCXX_3.4.10");
192 known_versions.push_back("GLIBCXX_LDBL_3.4.10");
193 known_versions.push_back("GLIBCXX_3.4.11");
194 known_versions.push_back("GLIBCXX_3.4.12");
195 known_versions.push_back("GLIBCXX_3.4.13");
196 known_versions.push_back("GLIBCXX_3.4.14");
197 known_versions.push_back("GLIBCXX_3.4.15");
198 known_versions.push_back("GLIBCXX_3.4.16");
199 known_versions.push_back("GLIBCXX_3.4.17");
200 known_versions.push_back("GLIBCXX_3.4.18");
201 known_versions.push_back("GLIBCXX_3.4.19");
202 known_versions.push_back("GLIBCXX_3.4.20");
203 known_versions.push_back("GLIBCXX_3.4.21");
204 known_versions.push_back("GLIBCXX_LDBL_3.4.21");
205 known_versions.push_back("GLIBCXX_3.4.22");
206 known_versions.push_back("GLIBCXX_3.4.23");
207 known_versions.push_back("GLIBCXX_3.4.24");
208 known_versions.push_back("CXXABI_1.3");
209 known_versions.push_back("CXXABI_LDBL_1.3");
210 known_versions.push_back("CXXABI_1.3.1");
211 known_versions.push_back("CXXABI_1.3.2");
212 known_versions.push_back("CXXABI_1.3.3");
213 known_versions.push_back("CXXABI_1.3.4");
214 known_versions.push_back("CXXABI_1.3.5");
215 known_versions.push_back("CXXABI_1.3.6");
216 known_versions.push_back("CXXABI_1.3.7");
217 known_versions.push_back("CXXABI_1.3.8");
218 known_versions.push_back("CXXABI_1.3.9");
219 known_versions.push_back("CXXABI_1.3.10");
220 known_versions.push_back("CXXABI_1.3.11");
221 known_versions.push_back("CXXABI_TM_1");
222 known_versions.push_back("CXXABI_FLOAT128");
224 compat_list::iterator begin = known_versions.begin();
225 compat_list::iterator end = known_versions.end();
227 // Check for compatible version.
228 if (test.version_name.size())
230 compat_list::iterator it1 = find(begin, end, test.version_name);
231 compat_list::iterator it2 = find(begin, end, test.name);
232 if (it1 != end)
233 test.version_status = symbol::compatible;
234 else
235 test.version_status = symbol::incompatible;
237 // Check that added symbols are added in the latest pre-release version.
238 bool latestp = (test.version_name == "GLIBCXX_3.4.24"
239 || test.version_name == "CXXABI_1.3.11"
240 || test.version_name == "CXXABI_FLOAT128"
241 || test.version_name == "CXXABI_TM_1");
242 if (added && !latestp)
243 test.version_status = symbol::incompatible;
245 // Check that long double compatibility symbols demangled as
246 // __float128 and regular __float128 symbols are put into some _LDBL_
247 // or _FLOAT128 version name.
248 if (added && test.demangled_name.find("__float128") != std::string::npos
249 && test.demangled_name.find("std::__cxx11::") != 0)
251 if (test.version_name.find("_LDBL_") == std::string::npos
252 && test.version_name.find("_FLOAT128") == std::string::npos)
253 test.version_status = symbol::incompatible;
256 // Check for weak label.
257 if (it1 == end && it2 == end)
258 test.version_status = symbol::incompatible;
260 // Check that
261 // GLIBCXX_3.4
262 // GLIBCXX_3.4.5
263 // version as compatible
264 // XXX
266 else
268 if (added)
270 // New version labels are ok. The rest are not.
271 compat_list::iterator it2 = find(begin, end, test.name);
272 if (it2 != end)
273 test.version_status = symbol::compatible;
274 else
275 test.version_status = symbol::incompatible;
278 return test.version_status == symbol::compatible;
281 bool
282 check_compatible(symbol& lhs, symbol& rhs, bool verbose)
284 bool ret = true;
285 const char tab = '\t';
287 // Check to see if symbol_objects are compatible.
288 if (lhs.type != rhs.type)
290 ret = false;
291 if (verbose)
292 cout << tab << "incompatible types" << endl;
295 if (lhs.name != rhs.name)
297 ret = false;
298 if (verbose)
299 cout << tab << "incompatible names" << endl;
302 if (lhs.size != rhs.size)
304 ret = false;
305 if (verbose)
307 cout << tab << "incompatible sizes" << endl;
308 cout << tab << lhs.size << endl;
309 cout << tab << rhs.size << endl;
313 if (lhs.version_name != rhs.version_name
314 && !check_version(lhs) && !check_version(rhs))
316 ret = false;
317 if (verbose)
319 cout << tab << "incompatible versions" << endl;
320 cout << tab << lhs.version_name << endl;
321 cout << tab << rhs.version_name << endl;
325 if (verbose)
326 cout << endl;
328 return ret;
332 inline bool
333 has_symbol(const string& name, const symbols& s) throw()
334 { return s.find(name) != s.end(); }
336 const symbol&
337 get_symbol(const string& name, const symbols& s)
339 symbols::const_iterator i = s.find(name);
340 if (i != s.end())
342 return i->second;
344 else
346 ostringstream os;
347 os << "get_symbol failed for symbol " << name;
348 __throw_logic_error(os.str().c_str());
352 void
353 examine_symbol(const char* name, const char* file)
357 symbols s = create_symbols(file);
358 const symbol& sym = get_symbol(name, s);
359 sym.print();
361 catch(...)
362 { __throw_exception_again; }
366 compare_symbols(const char* baseline_file, const char* test_file,
367 bool verbose)
369 // Input both lists of symbols into container.
370 symbols baseline = create_symbols(baseline_file);
371 symbols test = create_symbols(test_file);
373 // Sanity check results.
374 if (!baseline.size() || !test.size())
376 cerr << "Problems parsing the list of exported symbols." << endl;
377 exit(2);
380 // Check to see if any long double compatibility symbols are produced.
381 bool ld_version_found(false);
382 symbols::iterator li(test.begin());
383 while (!ld_version_found && li != test.end())
385 if (li->second.version_name.find("_LDBL_") != std::string::npos)
386 ld_version_found = true;
387 ++li;
390 // Sort out names.
391 // Assuming all baseline names and test names are both unique w/ no
392 // duplicates.
394 // The names added to missing_names are baseline names not found in
395 // test names
396 // -> symbols that have been deleted.
398 // The names added to added_names are test names not in
399 // baseline names
400 // -> symbols that have been added.
401 typedef std::vector<std::string> symbol_names;
402 symbol_names shared_names;
403 symbol_names missing_names;
404 symbol_names added_names;
405 for (li = test.begin(); li != test.end(); ++li)
406 added_names.push_back(li->first);
408 for (symbols::iterator i = baseline.begin(); i != baseline.end(); ++i)
410 string name(i->first);
411 symbol_names::iterator end = added_names.end();
412 symbol_names::iterator it = find(added_names.begin(), end, name);
413 if (it != end)
415 // Found.
416 shared_names.push_back(name);
417 added_names.erase(it);
419 else
421 // Iff no test long double compatibility symbols at all and the symbol
422 // missing is a baseline long double compatibility symbol, skip.
423 string version_name(i->second.version_name);
424 bool base_ld(version_name.find("_LDBL_") != std::string::npos);
425 if (!base_ld || base_ld && ld_version_found)
426 missing_names.push_back(name);
430 // Fill out list of incompatible symbols.
431 typedef pair<symbol, symbol> symbol_pair;
432 vector<symbol_pair> incompatible;
434 // Fill out list of undesignated symbols.
435 vector<symbol> undesignated;
437 // Check missing names for compatibility.
438 for (size_t j = 0; j < missing_names.size(); ++j)
440 symbol& sbase = baseline[missing_names[j]];
441 sbase.status = symbol::subtracted;
442 incompatible.push_back(symbol_pair(sbase, sbase));
445 // Check shared names for compatibility.
446 const symbol_names::size_type shared_size = shared_names.size();
447 for (size_t k = 0; k < shared_size; ++k)
449 symbol& sbase = baseline[shared_names[k]];
450 symbol& stest = test[shared_names[k]];
451 stest.status = symbol::existing;
452 if (!check_compatible(sbase, stest))
453 incompatible.push_back(symbol_pair(sbase, stest));
456 // Check added names for compatibility.
457 const symbol_names::size_type added_size = added_names.size();
458 for (size_t l = 0; l < added_size; ++l)
460 symbol& stest = test[added_names[l]];
462 // Mark TLS as undesignated, remove from added.
463 if (stest.type == symbol::tls)
465 stest.status = symbol::undesignated;
466 if (!check_version(stest, false))
467 incompatible.push_back(symbol_pair(stest, stest));
468 else
469 undesignated.push_back(stest);
471 else
473 stest.status = symbol::added;
474 if (!check_version(stest, true))
475 incompatible.push_back(symbol_pair(stest, stest));
479 // Normalize added names and undesignated names.
480 const size_t undesignated_size = undesignated.size();
481 for (size_t l = 0; l < undesignated_size; ++l)
483 symbol& sundes = undesignated[l];
484 symbol_names::iterator end = added_names.end();
485 symbol_names::iterator it = find(added_names.begin(), end, sundes.name);
486 if (it != end)
488 // Found.
489 added_names.erase(it);
491 else
492 __throw_runtime_error(sundes.name.c_str());
496 // Report results.
497 if (verbose && added_names.size())
499 cout << endl << added_names.size() << " added symbols " << endl;
500 for (size_t j = 0; j < added_names.size() ; ++j)
502 cout << j << endl;
503 test[added_names[j]].print();
507 if (verbose && missing_names.size())
509 cout << endl << missing_names.size() << " missing symbols " << endl;
510 for (size_t j = 0; j < missing_names.size() ; ++j)
512 cout << j << endl;
513 baseline[missing_names[j]].print();
517 if (verbose && undesignated.size())
519 cout << endl << undesignated.size() << " undesignated symbols " << endl;
520 for (size_t j = 0; j < undesignated.size() ; ++j)
522 // First, print index.
523 cout << j << endl;
525 // Second, report name.
526 symbol& s = undesignated[j];
527 s.print();
531 if (verbose && incompatible.size())
533 cout << endl << incompatible.size() << " incompatible symbols " << endl;
534 for (size_t j = 0; j < incompatible.size() ; ++j)
536 // First, print index.
537 cout << j << endl;
539 // Second, report name.
540 symbol& sbase = incompatible[j].first;
541 symbol& stest = incompatible[j].second;
542 stest.print();
544 // Third, report reason or reasons incompatible.
545 check_compatible(sbase, stest, true);
549 cout << "\n\t\t==== libstdc++-v3 check-abi Summary ====" << endl;
550 cout << endl;
551 cout << "# of added symbols:\t\t " << added_names.size() << endl;
552 cout << "# of missing symbols:\t\t " << missing_names.size() << endl;
553 cout << "# of undesignated symbols:\t " << undesignated.size() << endl;
554 cout << "# of incompatible symbols:\t " << incompatible.size() << endl;
555 cout << endl;
556 cout << "using: " << baseline_file << endl;
558 return !(missing_names.size() || incompatible.size());
562 symbols
563 create_symbols(const char* file)
565 symbols s;
566 ifstream ifs(file);
567 if (ifs.is_open())
569 // Organize file data into an associated container (symbols) of symbol
570 // objects mapped to mangled names without versioning
571 // information.
572 const string empty;
573 string line = empty;
574 while (getline(ifs, line).good())
576 symbol tmp;
577 tmp.init(line);
578 s[tmp.name] = tmp;
579 line = empty;
582 else
584 ostringstream os;
585 os << "create_symbols failed for file " << file;
586 __throw_runtime_error(os.str().c_str());
588 return s;
592 const char*
593 demangle(const std::string& mangled)
595 const char* name;
596 if (mangled[0] != '_' || mangled[1] != 'Z')
598 // This is not a mangled symbol, thus has "C" linkage.
599 name = mangled.c_str();
601 else
603 // Use __cxa_demangle to demangle.
604 int status = 0;
605 name = abi::__cxa_demangle(mangled.c_str(), 0, 0, &status);
606 if (!name)
608 switch (status)
610 case 0:
611 name = "error code = 0: success";
612 break;
613 case -1:
614 name = "error code = -1: memory allocation failure";
615 break;
616 case -2:
617 name = "error code = -2: invalid mangled name";
618 break;
619 case -3:
620 name = "error code = -3: invalid arguments";
621 break;
622 default:
623 name = "error code unknown - who knows what happened";
627 return name;